diff --git a/.github/workflows/run_tests.yml b/.github/workflows/run_tests.yml index 3eb8ddc18..35bb000d1 100644 --- a/.github/workflows/run_tests.yml +++ b/.github/workflows/run_tests.yml @@ -58,23 +58,3 @@ jobs: max-jobs = 4 run: | nix build -L .?submodules=1#checks.x86_64-linux.default - results_dir="./results" - mkdir -p "$results_dir" - cp -r ./result/* "$results_dir/all-checks" - rm -rf result - - name: Publish Test Results - uses: EnricoMi/publish-unit-test-result-action/linux@v2 - with: - check_name: "Linux Test Results" - files: "results/**/*.xml" - comment_mode: ${{ github.event.pull_request.head.repo.fork && 'off' || 'always' }} # Don't create PR comment from fork runs - action_fail_on_inconclusive: true # fail, if no reports - action_fail: true - - name: 'Upload Artifacts' - uses: actions/upload-artifact@v4 - with: - name: junit-test-results - path: "results/**/*.xml" - retention-days: 5 - if-no-files-found: error - overwrite: true diff --git a/.gitmodules b/.gitmodules index 9a8fc2247..e69de29bb 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +0,0 @@ -[submodule "cmake/modules"] - path = cmake/modules - url = https://github.com/BoostCMake/cmake_modules.git diff --git a/CMakeLists.txt b/CMakeLists.txt index 4aaa46ced..43c0cf3d0 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,14 +1,11 @@ cmake_minimum_required(VERSION 3.21.4) -list(APPEND CMAKE_MODULE_PATH - "${CMAKE_CURRENT_LIST_DIR}/cmake/modules/share/modules/cmake" -) - project(crypto3_blueprint VERSION 0.1.0 LANGUAGES C CXX) option(CMAKE_ENABLE_TESTS "Enable tests" FALSE) # used by CMTest module option(BUILD_EXAMPLES "Build examples" FALSE) +find_package(CM) find_package(crypto3 REQUIRED) find_package(Boost REQUIRED COMPONENTS container random filesystem log log_setup program_options thread system) @@ -48,12 +45,6 @@ include(CMakePackageConfigHelpers) set(CONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/crypto3_blueprint) set(PACKAGE_CONFIG_NAME crypto3_blueprint-config) -configure_package_config_file( - cmake/Config.cmake.in - ${PACKAGE_CONFIG_NAME}.cmake - INSTALL_DESTINATION ${CONFIG_DIR} -) - write_basic_config_version_file( ${PACKAGE_CONFIG_NAME}-version.cmake VERSION ${crypto3_blueprint_VERSION} diff --git a/cmake/modules b/cmake/modules deleted file mode 160000 index 57639741e..000000000 --- a/cmake/modules +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 57639741ecf018835deb97a04db2200241d7fbd3 diff --git a/flake.lock b/flake.lock index 4a2de954c..175d8aef5 100644 --- a/flake.lock +++ b/flake.lock @@ -18,34 +18,72 @@ "type": "github" } }, + "flake-utils_2": { + "inputs": { + "systems": "systems_2" + }, + "locked": { + "lastModified": 1710146030, + "narHash": "sha256-SZ5L6eA7HJ/nmkzGG7/ISclqe6oZdOZTNoesiInkXPQ=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "b1d9ab70662946ef0850d488da1c9019f3a9752a", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, "nil-crypto3": { + "inputs": { + "flake-utils": "flake-utils_2", + "nix-3rdparty": "nix-3rdparty", + "nixpkgs": [ + "nixpkgs" + ] + }, + "locked": { + "lastModified": 1721720987, + "narHash": "sha256-+ah13O1r8cUZOJpv5AKFbl5WmsGc2bBkiji8gKZY8cU=", + "ref": "refs/heads/master", + "rev": "87edbf57f8ff14ed31ab67180dd504a229e2be87", + "revCount": 9161, + "type": "git", + "url": "https://github.com/NilFoundation/crypto3" + }, + "original": { + "type": "git", + "url": "https://github.com/NilFoundation/crypto3" + } + }, + "nix-3rdparty": { "inputs": { "flake-utils": [ + "nil-crypto3", "flake-utils" ], - "nix-3rdparty": [ - "nix-3rdparty" - ], "nixpkgs": [ + "nil-crypto3", "nixpkgs" ] }, "locked": { - "lastModified": 1721117852, - "narHash": "sha256-yFbFNBILX3hPLjKQXNh1BEjFfDRiZoCjpozcFkQ8VtQ=", + "lastModified": 1717519917, + "narHash": "sha256-GqzEqEW4Uz9Z7uDZwers0t9seWRNbRWPNE3OJnjE1Uw=", "owner": "NilFoundation", - "repo": "crypto3", - "rev": "4e3ea865478cbfd44146e113ca554333626dfc9b", + "repo": "nix-3rdparty", + "rev": "a2e45429aa25a4a6e8e362ef17df6f197312f224", "type": "github" }, "original": { "owner": "NilFoundation", - "repo": "crypto3", - "rev": "4e3ea865478cbfd44146e113ca554333626dfc9b", + "repo": "nix-3rdparty", "type": "github" } }, - "nix-3rdparty": { + "nix-3rdparty_2": { "inputs": { "flake-utils": [ "flake-utils" @@ -55,11 +93,11 @@ ] }, "locked": { - "lastModified": 1717519917, - "narHash": "sha256-GqzEqEW4Uz9Z7uDZwers0t9seWRNbRWPNE3OJnjE1Uw=", + "lastModified": 1721822436, + "narHash": "sha256-AQidmv80fA72FFHgyjCq9Psc04w9aaHedJpoVgnLb6M=", "owner": "NilFoundation", "repo": "nix-3rdparty", - "rev": "a2e45429aa25a4a6e8e362ef17df6f197312f224", + "rev": "d14a2a3c4b9498b297400b225fc09570bfe0a9a1", "type": "github" }, "original": { @@ -70,16 +108,15 @@ }, "nixpkgs": { "locked": { - "lastModified": 1721226092, - "narHash": "sha256-UBvzVpo5sXSi2S/Av+t+Q+C2mhMIw/LBEZR+d6NMjws=", + "lastModified": 1721896952, + "narHash": "sha256-79GOgbHd0oKpANpuw6gnc5Et+QZrMsNk+NENAnW5CUQ=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "c716603a63aca44f39bef1986c13402167450e0a", + "rev": "a9d164fed4d92ccacfdd55c383bcca3cc4a69619", "type": "github" }, "original": { "owner": "NixOS", - "ref": "nixos-24.05", "repo": "nixpkgs", "type": "github" } @@ -88,7 +125,7 @@ "inputs": { "flake-utils": "flake-utils", "nil-crypto3": "nil-crypto3", - "nix-3rdparty": "nix-3rdparty", + "nix-3rdparty": "nix-3rdparty_2", "nixpkgs": "nixpkgs" } }, @@ -106,6 +143,21 @@ "repo": "default", "type": "github" } + }, + "systems_2": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } } }, "root": "root", diff --git a/flake.nix b/flake.nix index bf4fff61f..4434d8c1d 100644 --- a/flake.nix +++ b/flake.nix @@ -2,7 +2,7 @@ description = "Nix flake for zkllvm-blueprint"; inputs = { - nixpkgs.url = "github:NixOS/nixpkgs/nixos-24.05"; + nixpkgs.url = "github:NixOS/nixpkgs"; flake-utils.url = "github:numtide/flake-utils"; nix-3rdparty = { url = "github:NilFoundation/nix-3rdparty"; @@ -12,13 +12,10 @@ }; }; nil-crypto3 = { - type = "github"; - owner = "NilFoundation"; - repo = "crypto3"; + url = "https://github.com/NilFoundation/crypto3"; + type = "git"; inputs = { nixpkgs.follows = "nixpkgs"; - flake-utils.follows = "flake-utils"; - nix-3rdparty.follows = "nix-3rdparty"; }; }; }; @@ -29,175 +26,52 @@ pkgs = import nixpkgs { inherit system; }; stdenv = pkgs.llvmPackages_16.stdenv; crypto3 = nil-crypto3.packages.${system}.crypto3; - in rec { + cmake_modules = nix-3rdparty.packages.${system}.cmake_modules; + in { packages = rec { - zkllvm-blueprint = stdenv.mkDerivation { - name = "zkllvm-blueprint"; - - src = self; - - buildInputs = with pkgs; [ - cmake - pkg-config - clang_16 - ]; - - propagatedBuildInputs = [ crypto3 pkgs.boost183 ]; - - cmakeBuildType = "Release"; - - cmakeFlags = [ - "-DCMAKE_CXX_STANDARD=17" - ]; - - doCheck = false; - }; - default = zkllvm-blueprint; + zkllvm-blueprint = (pkgs.callPackage ./zkllvm-blueprint.nix { + src_repo = self; + crypto3 = crypto3; + cmake_modules = cmake_modules; + }); + zkllvm-blueprint-debug = (pkgs.callPackage ./zkllvm-blueprint.nix { + src_repo = self; + crypto3 = crypto3; + cmake_modules = cmake_modules; + enableDebug = true; + }); + zkllvm-blueprint-debug-tests = (pkgs.callPackage ./zkllvm-blueprint.nix { + src_repo = self; + crypto3 = crypto3; + cmake_modules = cmake_modules; + enableDebug = true; + runTests = true; + }); + default = zkllvm-blueprint-debug-tests; }; - - testList = [ - "blueprint_algebra_fields_plonk_field_operations_test" - "blueprint_algebra_fields_plonk_exponentiation_test" - "blueprint_algebra_curves_plonk_unified_addition_test" - "blueprint_algebra_curves_plonk_variable_base_scalar_mul_test" - "blueprint_verifiers_kimchi_sponge_oracles_test" - "blueprint_hashes_plonk_poseidon_test" - "blueprint_algebra_curves_plonk_endo_scalar_test" - "blueprint_algebra_fields_plonk_range_check_test" - "blueprint_algebra_fields_plonk_logic_and_flag_test" - "blueprint_algebra_fields_plonk_logic_or_flag_test" - "blueprint_algebra_fields_plonk_interpolation_test" - "blueprint_algebra_fields_plonk_non_native_addition_test" - "blueprint_algebra_fields_plonk_non_native_subtraction_test" - "blueprint_algebra_fields_plonk_non_native_multiplication_test" - "blueprint_algebra_fields_plonk_non_native_range_test" - "blueprint_algebra_fields_plonk_non_native_reduction_test" - "blueprint_algebra_fields_plonk_non_native_bit_decomposition_test" - "blueprint_algebra_fields_plonk_non_native_bit_composition_test" - "blueprint_algebra_fields_plonk_non_native_bit_shift_constant_test" - "blueprint_algebra_fields_plonk_non_native_logic_ops_test" - "blueprint_algebra_fields_plonk_non_native_lookup_logic_ops_test" - "blueprint_algebra_fields_plonk_non_native_comparison_checked_test" - "blueprint_algebra_fields_plonk_non_native_comparison_unchecked_test" - "blueprint_algebra_fields_plonk_non_native_comparison_flag_test" - "blueprint_algebra_fields_plonk_non_native_equality_flag_test" - "blueprint_algebra_fields_plonk_non_native_division_remainder_test" - #blueprint_non_native_plonk_scalar_non_native_range_test, TODO: enable once fixed. - "blueprint_non_native_plonk_bool_scalar_multiplication_test" - "blueprint_non_native_plonk_add_mul_zkllvm_compatible_test" - "blueprint_hashes_plonk_decomposition_test" - "blueprint_verifiers_placeholder_fri_cosets_test" - "blueprint_hashes_plonk_sha256_process_test" - "blueprint_hashes_plonk_sha512_process_test" - "blueprint_hashes_plonk_sha256_test" - "blueprint_hashes_plonk_sha512_test" - "blueprint_algebra_fields_plonk_sqrt_test" - "blueprint_verifiers_placeholder_fri_lin_inter_test" - "blueprint_verifiers_placeholder_fri_array_swap_test" - "blueprint_manifest_test" - "blueprint_detail_huang_lu_test" - "blueprint_private_input_test" - "blueprint_verifiers_placeholder_permutation_argument_verifier_test" - "blueprint_verifiers_placeholder_gate_argument_verifier_test" - "blueprint_verifiers_placeholder_lookup_argument_verifier_test" - "blueprint_verifiers_placeholder_f1_loop_test" - "blueprint_verifiers_placeholder_f3_loop_test" - "blueprint_verifiers_placeholder_gate_component_test" - "blueprint_verifiers_flexible_pow_factor_test" - "blueprint_proxy_test" - #blueprint_mock_mocked_components_test, TODO: Enable after code and test re-written. - "blueprint_component_batch_test" - "blueprint_verifiers_placeholder_expression_evaluation_component_test" - "blueprint_verifiers_placeholder_final_polynomial_check_test" - "blueprint_verifiers_flexible_swap_test" - "blueprint_verifiers_flexible_additions_test" - "blueprint_verifiers_flexible_multiplications_test" - "blueprint_verifiers_flexible_poseidon_test" - "blueprint_verifiers_flexible_constant_pow_test" - "blueprint_verifiers_placeholder_verifier_test" - "blueprint_zkevm_zkevm_word_test" - "blueprint_zkevm_bytecode_test" - "blueprint_zkevm_state_selector_test" - "blueprint_zkevm_state_transition_test" - "blueprint_zkevm_opcodes_iszero_test" - "blueprint_zkevm_opcodes_add_sub_test" - "blueprint_zkevm_opcodes_mul_test" - "blueprint_zkevm_opcodes_div_test" - ]; - - checks = { - default = stdenv.mkDerivation { - name = "zkllvm-blueprint-tests"; - - src = self; - - buildInputs = with pkgs; [ - cmake - ninja - pkg-config - clang_16 - boost183 - crypto3 - ]; - - cmakeBuildType = "Debug"; - - cmakeFlags = [ - "-DCMAKE_CXX_STANDARD=17" - "-DCMAKE_ENABLE_TESTS=TRUE" - "-DCMAKE_C_COMPILER=clang" - "-DCMAKE_CXX_COMPILER=clang++" - ]; - - ninjaFlags = pkgs.lib.strings.concatStringsSep " " (["-k 0"] ++ testList); - - doCheck = true; - - checkPhase = '' - # JUNIT file without explicit file name is generated after the name of the master test suite inside `CMAKE_CURRENT_SOURCE_DIR` (/build/source) - export BOOST_TEST_LOGGER=JUNIT:HRF - ctest --verbose -j $NIX_BUILD_CORES --output-on-failure -R "${nixpkgs.lib.concatStringsSep "|" testList}" || true - - mkdir -p ${placeholder "out"}/test-logs - find .. -type f -name '*_test.xml' -exec cp {} ${placeholder "out"}/test-logs \; - ''; - - dontInstall = true; - }; - }; - - devShells = { - default = pkgs.mkShell { - buildInputs = with pkgs; [ - cmake - pkg-config - boost183 - clang_16 - clang-tools_16 - crypto3 - ]; - - shellHook = '' - export NO_AT_BRIDGE="1" - function nil_test_runner() { - clear - filename=$(cat Makefile | grep "$2" | awk 'NR==1{print $NF}') - make -j$(nproc) "$filename" && ./test/$filename - } - function ctcmp() { - nil_test_runner blueprint $1 - } - echo "zkllvm-blueprint dev environment activated" - ''; + checks = rec { + gcc = (pkgs.callPackage ./zkllvm-blueprint.nix { + src_repo = self; + crypto3 = crypto3; + cmake_modules = cmake_modules; + runTests = true; + }); + clang = (pkgs.callPackage ./zkllvm-blueprint.nix { + stdenv = pkgs.llvmPackages_18.stdenv; + src_repo = self; + crypto3 = crypto3; + cmake_modules = cmake_modules; + runTests = true; + }); + all = pkgs.symlinkJoin { + name = "all"; + paths = [ gcc clang ]; }; + default = all; }; })); } -# 1 build crypto 3 locally with the command 'nix build -L .?submodules=1#' -# 2 use the local source of crypto3: 'nix develop --override-input nil-crypto3 /your/path/to/crypto3 .?submodules=1#' -# 3a to build all in blueprint: 'nix flake -L check .?submodules=1#' or build all and run tests: nix build -L .?submodules=1#checks.x86_64-linux.default -# 3b to build individual targets: -# nix develop . -c cmake -B build -DCMAKE_CXX_STANDARD=17 -DCMAKE_BUILD_TYPE=Debug -DCMAKE_ENABLE_TESTS=TRUE -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -# cd build -# nix develop ../ -c cmake --build . -t blueprint_verifiers_flexible_constant_pow_test +# `nix flake -L check` to run all tests (-L to output build logs) +# `nix flake show` to show derivations tree +# If build fails due to OOM, run `export NIX_CONFIG="cores = 2"` to set desired parallel level diff --git a/include/nil/blueprint/manifest.hpp b/include/nil/blueprint/manifest.hpp index 927f73313..e38052d0b 100644 --- a/include/nil/blueprint/manifest.hpp +++ b/include/nil/blueprint/manifest.hpp @@ -36,6 +36,7 @@ #include #include #include +#include #include #include diff --git a/run_tests.sh b/run_tests.sh new file mode 100755 index 000000000..39b75c74c --- /dev/null +++ b/run_tests.sh @@ -0,0 +1,77 @@ +#!/usr/bin/env bash +set -e + +declare -a TEST_LIST=(\ + "blueprint_algebra_fields_plonk_field_operations_test" + "blueprint_algebra_fields_plonk_exponentiation_test" + "blueprint_algebra_curves_plonk_unified_addition_test" + "blueprint_algebra_curves_plonk_variable_base_scalar_mul_test" + "blueprint_verifiers_kimchi_sponge_oracles_test" + "blueprint_hashes_plonk_poseidon_test" + "blueprint_algebra_curves_plonk_endo_scalar_test" + "blueprint_algebra_fields_plonk_range_check_test" + "blueprint_algebra_fields_plonk_logic_and_flag_test" + "blueprint_algebra_fields_plonk_logic_or_flag_test" + "blueprint_algebra_fields_plonk_interpolation_test" + "blueprint_algebra_fields_plonk_non_native_addition_test" + "blueprint_algebra_fields_plonk_non_native_subtraction_test" + "blueprint_algebra_fields_plonk_non_native_multiplication_test" + "blueprint_algebra_fields_plonk_non_native_range_test" + "blueprint_algebra_fields_plonk_non_native_reduction_test" + "blueprint_algebra_fields_plonk_non_native_bit_decomposition_test" + "blueprint_algebra_fields_plonk_non_native_bit_composition_test" + "blueprint_algebra_fields_plonk_non_native_bit_shift_constant_test" + "blueprint_algebra_fields_plonk_non_native_logic_ops_test" + "blueprint_algebra_fields_plonk_non_native_lookup_logic_ops_test" + "blueprint_algebra_fields_plonk_non_native_comparison_checked_test" + "blueprint_algebra_fields_plonk_non_native_comparison_unchecked_test" + "blueprint_algebra_fields_plonk_non_native_comparison_flag_test" + "blueprint_algebra_fields_plonk_non_native_equality_flag_test" + "blueprint_algebra_fields_plonk_non_native_division_remainder_test" + "blueprint_non_native_plonk_bool_scalar_multiplication_test" + "blueprint_non_native_plonk_add_mul_zkllvm_compatible_test" + "blueprint_hashes_plonk_decomposition_test" + "blueprint_verifiers_placeholder_fri_cosets_test" + "blueprint_hashes_plonk_sha256_process_test" + "blueprint_hashes_plonk_sha512_process_test" + "blueprint_hashes_plonk_sha256_test" + "blueprint_hashes_plonk_sha512_test" + "blueprint_algebra_fields_plonk_sqrt_test" + "blueprint_verifiers_placeholder_fri_lin_inter_test" + "blueprint_verifiers_placeholder_fri_array_swap_test" + "blueprint_manifest_test" + "blueprint_detail_huang_lu_test" + "blueprint_private_input_test" + "blueprint_verifiers_placeholder_permutation_argument_verifier_test" + "blueprint_verifiers_placeholder_gate_argument_verifier_test" + "blueprint_verifiers_placeholder_lookup_argument_verifier_test" + "blueprint_verifiers_placeholder_f1_loop_test" + "blueprint_verifiers_placeholder_f3_loop_test" + "blueprint_verifiers_placeholder_gate_component_test" + "blueprint_verifiers_flexible_pow_factor_test" + "blueprint_proxy_test" + "blueprint_component_batch_test" + "blueprint_verifiers_placeholder_expression_evaluation_component_test" + "blueprint_verifiers_placeholder_final_polynomial_check_test" + "blueprint_verifiers_flexible_swap_test" + "blueprint_verifiers_flexible_additions_test" + "blueprint_verifiers_flexible_multiplications_test" + "blueprint_verifiers_flexible_poseidon_test" + "blueprint_verifiers_flexible_constant_pow_test" + "blueprint_verifiers_placeholder_verifier_test" + "blueprint_zkevm_zkevm_word_test" + "blueprint_zkevm_bytecode_test" + "blueprint_zkevm_state_selector_test" + "blueprint_zkevm_state_transition_test" + "blueprint_zkevm_opcodes_iszero_test" + "blueprint_zkevm_opcodes_add_sub_test" + "blueprint_zkevm_opcodes_mul_test" + "blueprint_zkevm_opcodes_div_test" +) +#blueprint_non_native_plonk_scalar_non_native_range_test, TODO: enable once fixed. +#blueprint_mock_mocked_components_test, TODO: Enable after code and test re-written. + +echo "building ${TEST_LIST[*]}" +ninja -k 0 -j $NIX_BUILD_CORES ${TEST_LIST[*]} + +echo "finish" diff --git a/test/component_batch.cpp b/test/component_batch.cpp index 725707f4d..bc7a314f6 100644 --- a/test/component_batch.cpp +++ b/test/component_batch.cpp @@ -84,23 +84,23 @@ template struct public_input_var_maker { using var = crypto3::zk::snark::plonk_variable; using assignment_type = assignment>; - assignment_type& assignment; + assignment_type& assignment_table; nil::crypto3::random::algebraic_engine generate_random; boost::random::uniform_int_distribution bool_dist{0, 1}; boost::random::mt19937 seed_seq{1444}; std::size_t curr_idx = 0; - public_input_var_maker(assignment_type& assignment_) : assignment(assignment_) { + public_input_var_maker(assignment_type& assignment_) : assignment_table(assignment_) { generate_random.seed(seed_seq); } var operator()() { - assignment.public_input(0, curr_idx) = generate_random(); + assignment_table.public_input(0, curr_idx) = generate_random(); return var(0, curr_idx++, false, var::column_type::public_input); } var binary_var() { - assignment.public_input(0, curr_idx) = bool_dist(seed_seq); + assignment_table.public_input(0, curr_idx) = bool_dist(seed_seq); return var(0, curr_idx++, false, var::column_type::public_input); } }; @@ -118,15 +118,15 @@ BOOST_AUTO_TEST_CASE(component_batch_basic_test) { using constraint_type = crypto3::zk::snark::plonk_constraint; using copy_constraint_type = crypto3::zk::snark::plonk_copy_constraint; - assignment_type assignment(14, 1, 0, 1); + assignment_type assignment_table(14, 1, 0, 1); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); using component_type = components::multiplication< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - std::size_t row = assignment.finalize_component_batches(circuit, 0); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + std::size_t row = assignment_table.finalize_component_batches(circuit, 0); BOOST_CHECK_EQUAL(row, 1); BOOST_CHECK_EQUAL(circuit.gates().size(), 1); const auto &gate = circuit.gates()[0]; @@ -148,7 +148,7 @@ BOOST_AUTO_TEST_CASE(component_batch_basic_test) { }; BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); - // assignment.export_table(std::cout); + // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); } @@ -163,27 +163,27 @@ BOOST_AUTO_TEST_CASE(component_batch_continuation_test) { using constraint_type = crypto3::zk::snark::plonk_constraint; using copy_constraint_type = crypto3::zk::snark::plonk_copy_constraint; - assignment_type assignment(15, 1, 0, 2); + assignment_type assignment_table(15, 1, 0, 2); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); using component_type = components::multiplication< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; - auto first_result = assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - auto second_result = assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - auto third_result = assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - auto fourth_result = assignment.add_input_to_batch_assignment({first_result.output, second_result.output}); + auto first_result = assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + auto second_result = assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + auto third_result = assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + auto fourth_result = assignment_table.add_input_to_batch_assignment({first_result.output, second_result.output}); using addition_type = components::addition< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; std::size_t row = 0; addition_type add_component({0, 1, 2}, {}, {}); - auto addition_result = generate_assignments(add_component, assignment, {third_result.output, fourth_result.output}, row); - generate_circuit(add_component, circuit, assignment, {third_result.output, fourth_result.output}, row++); - auto fifth_result = assignment.add_input_to_batch_assignment({addition_result.output, public_input_var_maker()}); - generate_assignments(add_component, assignment, {addition_result.output, fifth_result.output}, row); - generate_circuit(add_component, circuit, assignment, {addition_result.output, fifth_result.output}, row++); - row = assignment.finalize_component_batches(circuit, row); + auto addition_result = generate_assignments(add_component, assignment_table, {third_result.output, fourth_result.output}, row); + generate_circuit(add_component, circuit, assignment_table, {third_result.output, fourth_result.output}, row++); + auto fifth_result = assignment_table.add_input_to_batch_assignment({addition_result.output, public_input_var_maker()}); + generate_assignments(add_component, assignment_table, {addition_result.output, fifth_result.output}, row); + generate_circuit(add_component, circuit, assignment_table, {addition_result.output, fifth_result.output}, row++); + row = assignment_table.finalize_component_batches(circuit, row); BOOST_CHECK_EQUAL(row, 4); BOOST_CHECK_EQUAL(circuit.gates().size(), 2); const auto &gate = circuit.gates()[1]; @@ -219,7 +219,7 @@ BOOST_AUTO_TEST_CASE(component_batch_continuation_test) { BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); - // assignment.export_table(std::cout); + // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); } @@ -234,37 +234,37 @@ BOOST_AUTO_TEST_CASE(component_batch_multibatch_test) { using constraint_type = crypto3::zk::snark::plonk_constraint; using copy_constraint_type = crypto3::zk::snark::plonk_copy_constraint; - assignment_type assignment(15, 1, 0, 3); + assignment_type assignment_table(15, 1, 0, 3); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); using mul_component_type = components::multiplication< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; using add_component_type = components::addition< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; using div_or_zero_component_type = components::division_or_zero; - auto mul_result = assignment.add_input_to_batch_assignment( + auto mul_result = assignment_table.add_input_to_batch_assignment( {public_input_var_maker(), public_input_var_maker()}); - auto add_result = assignment.add_input_to_batch_assignment({mul_result.output, public_input_var_maker()}); - auto mul_result_2 = assignment.add_input_to_batch_assignment({add_result.output, mul_result.output}); - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + auto add_result = assignment_table.add_input_to_batch_assignment({mul_result.output, public_input_var_maker()}); + auto mul_result_2 = assignment_table.add_input_to_batch_assignment({add_result.output, mul_result.output}); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); div_or_zero_component_type div_or_zero_component({0, 1, 2, 3, 4}, {}, {}); var div_or_zero_var = public_input_var_maker(); auto div_or_zero_res = generate_assignments( - div_or_zero_component, assignment, {mul_result_2.output, div_or_zero_var}, 0); - generate_circuit(div_or_zero_component, circuit, assignment, {mul_result_2.output, div_or_zero_var}, 0); - assignment.add_input_to_batch_assignment({div_or_zero_res.output, public_input_var_maker()}); - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); - assignment.add_input_to_batch_assignment({add_result.output, mul_result.output}); + div_or_zero_component, assignment_table, {mul_result_2.output, div_or_zero_var}, 0); + generate_circuit(div_or_zero_component, circuit, assignment_table, {mul_result_2.output, div_or_zero_var}, 0); + assignment_table.add_input_to_batch_assignment({div_or_zero_res.output, public_input_var_maker()}); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + assignment_table.add_input_to_batch_assignment({add_result.output, mul_result.output}); // duplicates, should not count! for (std::size_t i = 0; i < 5; i++) { - assignment.add_input_to_batch_assignment({add_result.output, mul_result.output}); + assignment_table.add_input_to_batch_assignment({add_result.output, mul_result.output}); } // not duplicates, should count for (std::size_t i = 0; i < 5; i++) { - assignment.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), public_input_var_maker()}); } - std::size_t row = assignment.finalize_component_batches(circuit, 1); + std::size_t row = assignment_table.finalize_component_batches(circuit, 1); BOOST_CHECK_EQUAL(row, 4); BOOST_CHECK_EQUAL(circuit.gates().size(), 3); @@ -340,7 +340,7 @@ BOOST_AUTO_TEST_CASE(component_batch_multibatch_test) { BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); - // assignment.export_table(std::cout); + // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); } @@ -356,9 +356,9 @@ BOOST_AUTO_TEST_CASE(component_batch_const_batch_test) { using lookup_constraint_type = crypto3::zk::snark::plonk_lookup_constraint; using copy_constraint_type = crypto3::zk::snark::plonk_copy_constraint; - assignment_type assignment(15, 1, 1, 3); + assignment_type assignment_table(15, 1, 1, 3); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); using multiplication_type = components::multiplication< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; @@ -368,36 +368,36 @@ BOOST_AUTO_TEST_CASE(component_batch_const_batch_test) { std::size_t row = 0; var mul_by_constant_input = public_input_var_maker(); auto mul_by_const_result = generate_assignments( - mul_by_constant_component, assignment, {mul_by_constant_input}, row); - generate_circuit(mul_by_constant_component, circuit, assignment, {mul_by_constant_input}, row++); + mul_by_constant_component, assignment_table, {mul_by_constant_input}, row); + generate_circuit(mul_by_constant_component, circuit, assignment_table, {mul_by_constant_input}, row++); lookup_constraint_type lookup_constraint; lookup_constraint.table_id = 0; lookup_constraint.lookup_input.push_back(constraint_type({var(0, 1, true, var::column_type::constant)})); std::size_t lookup_selector = circuit.add_lookup_gate(lookup_constraint); - assignment.enable_selector(lookup_selector, row++); + assignment_table.enable_selector(lookup_selector, row++); // filling the constants is required to resize the column - assignment.constant(0, row) = 1445; - assignment.enable_selector(lookup_selector, row++); - assignment.constant(0, row) = 1446; - auto mul_result = assignment.add_input_to_batch_assignment( - {assignment.add_batch_constant_variable(1), assignment.add_batch_constant_variable(2)}); + assignment_table.constant(0, row) = 1445; + assignment_table.enable_selector(lookup_selector, row++); + assignment_table.constant(0, row) = 1446; + auto mul_result = assignment_table.add_input_to_batch_assignment( + {assignment_table.add_batch_constant_variable(1), assignment_table.add_batch_constant_variable(2)}); // have to check lookup functionality manually - assignment.add_input_to_batch_assignment({public_input_var_maker(), mul_result.output}); - assignment.add_input_to_batch_assignment({mul_by_const_result.output, public_input_var_maker()}); - assignment.finalize_component_batches(circuit, row); - assignment.finalize_constant_batches(circuit, 0); + assignment_table.add_input_to_batch_assignment({public_input_var_maker(), mul_result.output}); + assignment_table.add_input_to_batch_assignment({mul_by_const_result.output, public_input_var_maker()}); + assignment_table.finalize_component_batches(circuit, row); + assignment_table.finalize_constant_batches(circuit, 0); // duplicates; should not count! for (std::size_t i = 0; i < 10; i++) { - assignment.add_batch_constant_variable(2); + assignment_table.add_batch_constant_variable(2); } - BOOST_ASSERT(assignment.constant(0, 0) == 1444); - BOOST_ASSERT(assignment.constant(0, 1) == 1); - BOOST_ASSERT(assignment.constant(0, 2) == 1445); - BOOST_ASSERT(assignment.constant(0, 3) == 1446); - BOOST_ASSERT(assignment.constant(0, 4) == 2); - BOOST_ASSERT(assignment.rows_amount() == 5); + BOOST_ASSERT(assignment_table.constant(0, 0) == 1444); + BOOST_ASSERT(assignment_table.constant(0, 1) == 1); + BOOST_ASSERT(assignment_table.constant(0, 2) == 1445); + BOOST_ASSERT(assignment_table.constant(0, 3) == 1446); + BOOST_ASSERT(assignment_table.constant(0, 4) == 2); + BOOST_ASSERT(assignment_table.rows_amount() == 5); const std::vector expected_copy_constraints = { {var(0, 0, false, var::column_type::public_input), var(0, 0, false, var::column_type::witness)}, @@ -411,7 +411,7 @@ BOOST_AUTO_TEST_CASE(component_batch_const_batch_test) { BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); - // assignment.export_table(std::cout); + // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); } @@ -429,22 +429,22 @@ BOOST_AUTO_TEST_CASE(component_batch_params_test) { using swap_component_type = components::flexible_swap; using input_type = typename swap_component_type::input_type; - assignment_type assignment(15, 1, 1, 3); + assignment_type assignment_table(15, 1, 1, 3); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); constexpr std::size_t size_small = 1; constexpr std::size_t size_big = 2; input_type input; input.inp = {public_input_var_maker.binary_var(), public_input_var_maker(), public_input_var_maker()}; - auto res_1 = assignment.add_input_to_batch_assignment(input); + auto res_1 = assignment_table.add_input_to_batch_assignment(input); input.inp = {public_input_var_maker.binary_var(), public_input_var_maker(), public_input_var_maker()}; - auto res_2 = assignment.add_input_to_batch_assignment(input); + auto res_2 = assignment_table.add_input_to_batch_assignment(input); input.inp = {public_input_var_maker.binary_var(), res_1.output[0], res_2.output[1]}; - auto res_3 = assignment.add_input_to_batch_assignment(input); - assignment.finalize_component_batches(circuit, 0); + auto res_3 = assignment_table.add_input_to_batch_assignment(input); + assignment_table.finalize_component_batches(circuit, 0); BOOST_CHECK_EQUAL(circuit.gates().size(), 1); const auto &gate_1 = circuit.gates()[0]; @@ -481,7 +481,7 @@ BOOST_AUTO_TEST_CASE(component_batch_params_test) { BOOST_ASSERT(compare_copy_constraint_vectors(circuit.copy_constraints(), expected_copy_constraints)); - // assignment.export_table(std::cout); + // assignment_table.export_table(std::cout); // circuit.export_circuit(std::cout); } @@ -493,26 +493,26 @@ BOOST_AUTO_TEST_CASE(component_batch_generate_circuit_variant_basic_test) { using circuit_type = circuit>; using ArithmetizationType = nil::crypto3::zk::snark::plonk_constraint_system; - assignment_type assignment(15, 1, 1, 3); + assignment_type assignment_table(15, 1, 1, 3); circuit_type circuit; - public_input_var_maker public_input_var_maker(assignment); + public_input_var_maker public_input_var_maker(assignment_table); using multiplication_type = components::multiplication< ArithmetizationType, field_type, nil::blueprint::basic_non_native_policy>; typename multiplication_type::input_type input_1 = {public_input_var_maker(), public_input_var_maker()}; typename multiplication_type::input_type input_2 = {public_input_var_maker(), public_input_var_maker()}; - auto res_1 = assignment.add_input_to_batch_circuit(input_1); - auto res_2 = assignment.add_input_to_batch_circuit(input_2); - BOOST_ASSERT(var_value(assignment, res_1.output) == 0); - BOOST_ASSERT(var_value(assignment, res_2.output) == 0); - res_1 = assignment.add_input_to_batch_assignment(input_1); - BOOST_ASSERT(var_value(assignment, res_1.output) == var_value(assignment, input_1.x) * var_value(assignment, input_1.y)); - BOOST_ASSERT(var_value(assignment, res_1.output) != 0); - BOOST_ASSERT(var_value(assignment, res_2.output) == 0); - res_2 = assignment.add_input_to_batch_assignment(input_2); - BOOST_ASSERT(var_value(assignment, res_2.output) == var_value(assignment, input_2.x) * var_value(assignment, input_2.y)); - BOOST_ASSERT(var_value(assignment, res_2.output) != 0); + auto res_1 = assignment_table.add_input_to_batch_circuit(input_1); + auto res_2 = assignment_table.add_input_to_batch_circuit(input_2); + BOOST_ASSERT(var_value(assignment_table, res_1.output) == 0); + BOOST_ASSERT(var_value(assignment_table, res_2.output) == 0); + res_1 = assignment_table.add_input_to_batch_assignment(input_1); + BOOST_ASSERT(var_value(assignment_table, res_1.output) == var_value(assignment_table, input_1.x) * var_value(assignment_table, input_1.y)); + BOOST_ASSERT(var_value(assignment_table, res_1.output) != 0); + BOOST_ASSERT(var_value(assignment_table, res_2.output) == 0); + res_2 = assignment_table.add_input_to_batch_assignment(input_2); + BOOST_ASSERT(var_value(assignment_table, res_2.output) == var_value(assignment_table, input_2.x) * var_value(assignment_table, input_2.y)); + BOOST_ASSERT(var_value(assignment_table, res_2.output) != 0); } BOOST_AUTO_TEST_SUITE_END() diff --git a/test/verifiers/placeholder/verifier.cpp b/test/verifiers/placeholder/verifier.cpp index 84abbcba5..9e2f75734 100644 --- a/test/verifiers/placeholder/verifier.cpp +++ b/test/verifiers/placeholder/verifier.cpp @@ -172,6 +172,8 @@ struct default_zkllvm_params { // TODO(martun): consider moving these functions to some shared location so other tests can re-use them. template static nil::crypto3::zk::snark::placeholder_proof load_proof(std::string filename) { + std::cout << "Loading proof from " << filename << std::endl; + using Endianness = nil::marshalling::option::big_endian; using TTypeBase = nil::marshalling::field_type; @@ -179,10 +181,10 @@ template iproof.open(filename); BOOST_ASSERT(iproof.is_open()); std::vector v; - BOOST_ASSERT(read_buffer_from_file(iproof, v)); + if (!read_buffer_from_file(iproof, v)) + throw "Unable to read proof from file."; iproof.close(); - using proof_type = nil::crypto3::zk::snark::placeholder_proof; using proof_marshalling_type = nil::crypto3::marshalling::types::placeholder_proof; @@ -190,6 +192,10 @@ template proof_marshalling_type marshalled_proof_data; auto read_iter = v.begin(); auto status = marshalled_proof_data.read(read_iter, v.size()); + if (status != nil::marshalling::status_type::success) { + std::cerr << "Status is " << make_error_code(status) << std::endl; + throw "Reading a marshalled object from buffer failed."; + } return nil::crypto3::marshalling::types::make_placeholder_proof( marshalled_proof_data); } @@ -277,8 +283,10 @@ gen_test_proof( ){ using src_placeholder_params = typename SrcParams::placeholder_params; using field_type = typename SrcParams::field_type; + using fri_params_type = typename SrcParams::lpc_type::fri_type::params_type; - auto fri_params = create_fri_params(std::ceil(std::log2(table_description.rows_amount)), 0); + fri_params_type fri_params(0, std::ceil(std::log2(table_description.rows_amount)), + src_placeholder_params::lambda, 4 /*expand_factor*/); typename SrcParams::commitment_scheme_type lpc_scheme(fri_params); std::cout <<"Preprocess public data" << std::endl; @@ -378,9 +386,13 @@ void test_multiple_arithmetizations(std::string folder_name){ // auto table_description = SrcParams::load_table_description(folder_name + "/assignment.tbl"); std::cout << "Start loading" << std::endl; auto constraint_system = SrcParams::load_circuit(folder_name + "/circuit.crct"); - std::cout << "Load constraint system" << std::endl; + std::cout << "Loaded the constraint system" << std::endl; + auto common_data = load_common_data(folder_name + "/common.dat"); + std::cout << "Loaded the common data" << std::endl; + auto proof = load_proof(folder_name + "/proof.bin"); + std::cout << "Loaded the proof" << std::endl; auto table_description = common_data.desc; auto fri_params = common_data.commitment_params; diff --git a/zkllvm-blueprint.nix b/zkllvm-blueprint.nix new file mode 100644 index 000000000..c6f0059c6 --- /dev/null +++ b/zkllvm-blueprint.nix @@ -0,0 +1,57 @@ +{ lib, + stdenv, + src_repo, + ninja, + pkg-config, + cmake, + boost183, + # We'll use boost183 by default, but you can override it + boost_lib ? boost183, + gdb, + cmake_modules, + crypto3, + enableDebugging, + enableDebug ? false, + runTests ? false, + }: +let + inherit (lib) optional; +in stdenv.mkDerivation rec { + name = "blueprint"; + + src = src_repo; + + nativeBuildInputs = [ cmake ninja pkg-config ] ++ (lib.optional (!stdenv.isDarwin) gdb); + + # enableDebugging will keep debug symbols in boost + propagatedBuildInputs = [ (if enableDebug then (enableDebugging boost_lib) else boost_lib) ]; + + buildInputs = [cmake_modules crypto3]; + + cmakeFlags = + [ + (if runTests then "-DBUILD_TESTS=TRUE" else "") + (if runTests then "-DCMAKE_ENABLE_TESTS=TRUE" else "") + (if enableDebug then "-DCMAKE_BUILD_TYPE=Debug" else "-DCMAKE_BUILD_TYPE=Release") + (if enableDebug then "-DCMAKE_CXX_FLAGS=-ggdb" else "") + (if enableDebug then "-DCMAKE_CXX_FLAGS=-O0" else "") + "-G Ninja" + ]; + + doBuild = false; + doCheck = runTests; + dontInstall = true; + + buildPhase = '' + echo "skip build" + ''; + + checkPhase = '' + bash ../run_tests.sh + ''; + + shellHook = '' + PS1="\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ " + echo "Welcome to Blueprint development environment!" + ''; +}