Use conan to build the project (#5)

mathbunnyru · web-flow · commit c123828c763d · 2026-02-04T18:27:58.000Z
* Use conan to build the project

* Add build workflow

* Fix command

* Prepare runner and run tests

* Rewrite docs

* Put private headers to private dir

* Use util from private too

* Use another header style

* Update openssl

* Improve build instructions
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -0,0 +1,64 @@
+name: Build and Test
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  build-and-test:
+    runs-on: heavy
+    container: ghcr.io/xrplf/clio-ci:14342e087ceb8b593027198bf9ef06a43833c696
+
+    strategy:
+      matrix:
+        conan_profile: [gcc, clang]
+        build_type: [Release, Debug]
+
+    env:
+      BUILD_DIR: build
+      BUILD_TYPE: ${{ matrix.build_type }}
+
+    steps:
+      - name: Cleanup workspace
+        if: ${{ runner.os == 'macOS' }}
+        uses: XRPLF/actions/cleanup-workspace@cf0433aa74563aead044a1e395610c96d65a37cf
+
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Prepare runner
+        uses: XRPLF/actions/prepare-runner@2cbf481018d930656e9276fcc20dc0e3a0be5b6d
+        with:
+          enable_ccache: false
+
+      - name: Run Conan
+        env:
+          CONAN_PROFILE: ${{ matrix.conan_profile }}
+        run: |
+          conan \
+          install . \
+          -of "${BUILD_DIR}" \
+          -b missing \
+          -s "build_type=${BUILD_TYPE}" \
+          -o "&:with_tests=True" \
+          --profile:all "${CONAN_PROFILE}"
+
+      - name: Run CMake
+        run: |
+          cmake \
+            -B "${BUILD_DIR}" \
+            -S . \
+            -G Ninja \
+            -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake \
+            -DCMAKE_BUILD_TYPE="${BUILD_TYPE}"
+
+      - name: Build
+        run: ninja
+        working-directory: ${{ env.BUILD_DIR }}
+
+      - name: Run tests
+        run: ctest --output-on-failure
+        working-directory: ${{ env.BUILD_DIR }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,25 +1,9 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.16)
 project(mpt-crypto C CXX)
 
 # --- Find Dependencies ---
 find_package(OpenSSL REQUIRED)
-
-set(SECP256K1_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../secp256k1" CACHE PATH "Path to secp256k1 source directory")
-
-if (NOT EXISTS ${SECP256K1_SOURCE_DIR}/CMakeLists.txt)
-    message(FATAL_ERROR "Could not find libsecp256k1 source directory at ${SECP256K1_SOURCE_DIR}.
-    Ensure it is located at the same level as the mpt-crypto directory.")
-endif ()
-
-# Configure libsecp256k1 build options
-set(SECP256K1_BUILD_TESTS OFF CACHE BOOL "" FORCE)
-set(SECP256K1_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-set(SECP256K1_BUILD_BENCHMARKS OFF CACHE BOOL "" FORCE)
-set(SECP256K1_BUILD_EXHAUSTIVE_TESTS OFF CACHE BOOL "" FORCE)
-
-# Add libsecp256k1 as a sub-project (it's now a peer, but CMake treats it as a sub-project here)
-# We provide a binary dir name since it's outside our current source tree
-add_subdirectory(${SECP256K1_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/secp256k1_build)
+find_package(secp256k1 REQUIRED)
 
 # --- Define The Library ---
 add_library(mpt-crypto
@@ -35,16 +19,18 @@ add_library(mpt-crypto
             src/proof_same_plaintext_multi_shared_r.c)
 
 # --- Set Include Directories ---
-target_include_directories(mpt-crypto PUBLIC include PRIVATE ${SECP256K1_SOURCE_DIR}/include
-                           PRIVATE ${SECP256K1_SOURCE_DIR}/src)
+target_include_directories(mpt-crypto PUBLIC include)
 
 # --- Set Compile Definitions ---
 target_compile_definitions(mpt-crypto PRIVATE USE_SCALAR_8X32 USE_FIELD_10X26 ECMULT_WINDOW_SIZE=15
                                               ECMULT_GEN_PREC_BITS=4)
 
 # --- Link Dependencies ---
-target_link_libraries(mpt-crypto PUBLIC secp256k1 PUBLIC OpenSSL::Crypto)
+target_link_libraries(mpt-crypto PUBLIC secp256k1::secp256k1 PUBLIC OpenSSL::Crypto)
 
 # --- Testing ---
-enable_testing()
-add_subdirectory(tests)
+option(ENABLE_TESTS "Enable building tests" ON)
+if (ENABLE_TESTS)
+    enable_testing()
+    add_subdirectory(tests)
+endif ()
diff --git a/README.md b/README.md
@@ -33,74 +33,59 @@ Before building, ensure you have the following installed:
 
 - **CMake** (version 3.10 or higher)
 - **C Compiler** (GCC, Clang, or AppleClang)
-- **OpenSSL 3.x** (development headers and libraries)
 
 On macOS with Homebrew:
 
 ```bash
-brew install cmake openssl@3
+brew install cmake
 ```
 
 On Ubuntu/Debian:
 
 ```bash
-sudo apt-get install cmake libssl-dev build-essential
+sudo apt-get install cmake build-essential
 ```
 
 ### Dependency Setup
 
-This library requires `libsecp256k1` as a sibling directory. Clone it from the bitcoin-core repository:
-
-```bash
-# From the parent directory of mpt-crypto
-cd ..
-git clone https://github.com/bitcoin-core/secp256k1.git
-```
-
-Your directory structure should look like:
-
-```text
-Projects/
-├── mpt-crypto/
-└── secp256k1/
-```
+Set up Conan using [xrpld's BUILD.md](https://github.com/XRPLF/rippled/blob/develop/BUILD.md#steps)
 
 ### Build Instructions
 
-1. **Create the build directory and configure:**
+Run following commands to build the library
+
+1. Create build directory:
 
    ```bash
-   cd mpt-crypto
-   mkdir -p build && cd build
-   cmake ..
+   mkdir build && cd build
    ```
 
-2. **Build the library and tests:**
+2. Buld dependencies:
 
    ```bash
-   make -j
+   conan install .. --build=missing -o "&:with_tests=True"
    ```
 
-#### Platform-Specific Notes
-
-**macOS (Apple Silicon):** If you encounter architecture mismatch errors with OpenSSL, explicitly set the architecture:
+3. Run CMake:
 
-```bash
-cmake -DCMAKE_OSX_ARCHITECTURES=arm64 ..
-```
+   ```bash
+   cmake .. \
+      -DCMAKE_BUILD_TYPE=Release \
+      -G Ninja \
+      -DCMAKE_TOOLCHAIN_FILE:FILEPATH=build/generators/conan_toolchain.cmake
+   ```
 
-**macOS (Intel):** Use `x86_64` instead:
+4. **Build the library and tests:**
 
-```bash
-cmake -DCMAKE_OSX_ARCHITECTURES=x86_64 ..
-```
+   ```bash
+   ninja
+   ```
 
 ### Running Tests
 
-After building, run the test suite using CTest:
+After building, run the test suite using CTest from the build directory:
 
 ```bash
-cd build
 ctest --output-on-failure
 ```
 
diff --git a/cmake/Findsecp256k1.cmake b/cmake/Findsecp256k1.cmake
diff --git a/conanfile.py b/conanfile.py
@@ -0,0 +1,58 @@
+from conan import ConanFile, tools
+from conan.tools.cmake import CMake, CMakeDeps, CMakeToolchain, cmake_layout
+from conan.tools.files import get
+
+required_conan_version = ">=2.0.0"
+
+
+class MptCryptoConan(ConanFile):
+    name = "mpt-crypto"
+    description = "MPT-Crypto: Cryptographic Primitives for Confidential Assets"
+    url = "https://github.com/XRPLF/mpt-crypto"
+    package_type = "library"
+    settings = "os", "arch", "compiler", "build_type"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "with_tests": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "with_tests": False,
+    }
+
+    requires = [
+        "openssl/3.5.5",
+        "secp256k1/0.7.0",
+    ]
+
+    def config_options(self):
+        if self.settings.os == "Windows":
+            del self.options.fPIC
+
+    def layout(self):
+        cmake_layout(self, src_folder="src")
+        self.folders.generators = "build/generators"
+
+    def generate(self):
+        tc = CMakeToolchain(self)
+        tc.variables["ENABLE_TESTS"] = self.options.with_tests
+        tc.generate()
+
+        deps = CMakeDeps(self)
+        deps.generate()
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def package(self):
+        cmake = CMake(self)
+        cmake.install()
+
+    def package_info(self):
+        self.cpp_info.libs = ["mpt-crypto"]
+        self.cpp_info.set_property("cmake_file_name", "mpt-crypto")
+        self.cpp_info.set_property("cmake_target_name", "mpt-crypto::mpt-crypto")
diff --git a/src/mpt_scalar.c b/src/mpt_scalar.c
@@ -47,13 +47,13 @@
 /* 2. Include low-level utilities first.
       On ARM64/Apple Silicon, the scalar math depends on 128-bit
       integer helpers defined in these headers. */
-#include "util.h"
-#include "int128.h"
-#include "int128_impl.h"
+#include <private/util.h>
+#include <private/int128.h>
+#include <private/int128_impl.h>
 
 /* 3. Include the actual scalar implementations */
-#include "scalar.h"
-#include "scalar_impl.h"
+#include <private/scalar.h>
+#include <private/scalar_impl.h>
 
 /* --- Implementation --- */
 
