From 79cb366b22072fca00e03dcb93d6f73e9ca0581d Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Fri, 18 Aug 2023 13:25:58 +0000 Subject: [PATCH 1/7] [SQUASHED] side-effect ordering work attempt... Fix a lot of compilation issues, 1 pending. Remove temp param from conditional_assign C++ compiles. add side effects to TS (wip) TS compiles. --- .../abis/combined_accumulated_data.hpp | 121 +++++---- .../circuits/abis/final_accumulated_data.hpp | 60 +++-- .../circuits/abis/new_contract_data.hpp | 14 +- .../abis/private_circuit_public_inputs.hpp | 155 +++++++---- .../abis/public_circuit_public_inputs.hpp | 27 +- .../src/aztec3/circuits/abis/side_effects.hpp | 252 ++++++++++++++++++ .../src/aztec3/circuits/abis/tx_request.hpp | 2 +- .../apps/function_execution_context.hpp | 20 +- .../aztec3/circuits/kernel/private/common.cpp | 66 +++-- .../aztec3/circuits/kernel/private/common.hpp | 4 +- .../native_private_kernel_circuit.test.cpp | 30 +-- .../native_private_kernel_circuit_init.cpp | 19 +- ...ative_private_kernel_circuit_init.test.cpp | 27 +- .../native_private_kernel_circuit_inner.cpp | 6 +- ...tive_private_kernel_circuit_inner.test.cpp | 59 ++-- ...native_private_kernel_circuit_ordering.cpp | 61 ++++- ...e_private_kernel_circuit_ordering.test.cpp | 93 ++++--- .../kernel/private/private_kernel_circuit.cpp | 66 +++-- .../kernel/private/testing_harness.cpp | 23 +- .../kernel/private/testing_harness.hpp | 4 +- .../aztec3/circuits/kernel/public/.test.cpp | 199 ++++++++------ .../aztec3/circuits/kernel/public/common.cpp | 2 +- .../aztec3/circuits/kernel/public/common.hpp | 60 +++-- .../src/aztec3/circuits/rollup/base/.test.cpp | 33 +-- .../base/native_base_rollup_circuit.cpp | 4 +- .../circuits/rollup/components/components.cpp | 7 +- .../src/aztec3/circuits/rollup/root/.test.cpp | 9 +- .../circuits/rollup/test_utils/utils.cpp | 27 +- .../circuits/rollup/test_utils/utils.hpp | 7 +- circuits/cpp/src/aztec3/constants.hpp | 46 +++- circuits/cpp/src/aztec3/utils/array.hpp | 163 +++++++++++ yarn-project/aztec-nr/aztec/src/abi.nr | 168 +++++++++--- yarn-project/aztec-nr/aztec/src/context.nr | 137 +++++++--- .../circuits.js/src/cbind/circuits.gen.ts | 192 ++++++++++--- yarn-project/circuits.js/src/cbind/types.ts | 3 + .../src/kernel/public_kernel.test.ts | 6 +- yarn-project/circuits.js/src/structs/index.ts | 1 + .../kernel/combined_accumulated_data.ts | 79 +++--- .../structs/private_circuit_public_inputs.ts | 26 +- .../structs/public_circuit_public_inputs.ts | 30 ++- .../circuits.js/src/structs/side_effects.ts | 165 ++++++++++++ .../circuits.js/src/tests/factories.ts | 76 ++++-- 42 files changed, 1891 insertions(+), 658 deletions(-) create mode 100644 circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp create mode 100644 yarn-project/circuits.js/src/structs/side_effects.ts diff --git a/circuits/cpp/src/aztec3/circuits/abis/combined_accumulated_data.hpp b/circuits/cpp/src/aztec3/circuits/abis/combined_accumulated_data.hpp index e3e2800a69cd..5fb5027778ab 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/combined_accumulated_data.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/combined_accumulated_data.hpp @@ -3,6 +3,7 @@ #include "optionally_revealed_data.hpp" #include "public_data_read.hpp" #include "public_data_update_request.hpp" +#include "side_effects.hpp" #include "aztec3/circuits/abis/membership_witness.hpp" #include "aztec3/circuits/abis/read_request_membership_witness.hpp" @@ -30,17 +31,18 @@ template struct CombinedAccumulatedData { AggregationObject aggregation_object{}; - std::array read_requests{}; + std::array, MAX_READ_REQUESTS_PER_TX> read_requests{}; - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; + // TODO(dbanks12): remove me! std::array nullified_commitments{}; // For pending nullifiers, we have: // nullifiedCommitments[j] != 0 <==> newNullifiers[j] nullifies nullifiedCommitments[j] - std::array private_call_stack{}; - std::array public_call_stack{}; - std::array new_l2_to_l1_msgs{}; + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX> private_call_stack{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX> public_call_stack{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_TX> new_l2_to_l1_msgs{}; std::array encrypted_logs_hash{}; std::array unencrypted_logs_hash{}; @@ -62,6 +64,7 @@ template struct CombinedAccumulatedData { read_requests, new_commitments, new_nullifiers, + // TODO(dbanks12): remove me! nullified_commitments, private_call_stack, public_call_stack, @@ -97,15 +100,16 @@ template struct CombinedAccumulatedData { aggregation_object.has_data, }, - to_ct(read_requests), + map(read_requests, to_circuit_type), - to_ct(new_commitments), - to_ct(new_nullifiers), + map(new_commitments, to_circuit_type), + map(new_nullifiers, to_circuit_type), + // TODO(dbanks12): remove me! to_ct(nullified_commitments), - to_ct(private_call_stack), - to_ct(public_call_stack), - to_ct(new_l2_to_l1_msgs), + map(private_call_stack, to_circuit_type), + map(public_call_stack, to_circuit_type), + map(new_l2_to_l1_msgs, to_circuit_type), to_ct(encrypted_logs_hash), to_ct(unencrypted_logs_hash), @@ -137,15 +141,16 @@ template struct CombinedAccumulatedData { aggregation_object.has_data, }, - to_nt(read_requests), + map(read_requests, to_native_type), - to_nt(new_commitments), - to_nt(new_nullifiers), + map(new_commitments, to_native_type), + map(new_nullifiers, to_native_type), + // TODO(dbanks12): remove me! to_nt(nullified_commitments), - to_nt(private_call_stack), - to_nt(public_call_stack), - to_nt(new_l2_to_l1_msgs), + map(private_call_stack, to_native_type), + map(public_call_stack, to_native_type), + map(new_l2_to_l1_msgs, to_native_type), to_nt(encrypted_logs_hash), to_nt(unencrypted_logs_hash), @@ -171,6 +176,7 @@ template struct CombinedAccumulatedData { set_array_public(new_commitments); set_array_public(new_nullifiers); + // TODO(dbanks12): remove me! set_array_public(nullified_commitments); set_array_public(private_call_stack); @@ -190,41 +196,58 @@ template struct CombinedAccumulatedData { { static_assert(!(std::is_same::value)); for (T& e : arr) { - fr(e).set_public(); - } - } - - template void set_array_public(std::array, SIZE>& arr) - { - static_assert(!(std::is_same::value)); - for (auto& e : arr) { - e.set_public(); - } - } - - template void set_array_public(std::array, SIZE>& arr) - { - static_assert(!(std::is_same::value)); - for (auto& e : arr) { e.set_public(); } } - template void set_array_public(std::array, SIZE>& arr) - { - static_assert(!(std::is_same::value)); - for (auto& e : arr) { - e.set_public(); - } - } - - template void set_array_public(std::array, SIZE>& arr) - { - static_assert(!(std::is_same::value)); - for (auto& e : arr) { - e.set_public(); - } - } + // template void set_array_public(std::array& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (T& e : arr) { + // fr(e).set_public(); + // } + // } + + // template + // void set_array_public(std::array, SIZE>& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (auto& e : arr) { + // e.set_public(); + // } + // } + + // template void set_array_public(std::array, SIZE>& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (auto& e : arr) { + // e.set_public(); + // } + // } + + // template void set_array_public(std::array, SIZE>& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (auto& e : arr) { + // e.set_public(); + // } + // } + + // template void set_array_public(std::array, SIZE>& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (auto& e : arr) { + // e.set_public(); + // } + // } + + // template void set_array_public(std::array, SIZE>& arr) + //{ + // static_assert(!(std::is_same::value)); + // for (auto& e : arr) { + // e.set_public(); + // } + // } }; } // namespace aztec3::circuits::abis diff --git a/circuits/cpp/src/aztec3/circuits/abis/final_accumulated_data.hpp b/circuits/cpp/src/aztec3/circuits/abis/final_accumulated_data.hpp index 9aba003e806f..25fbcde259d0 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/final_accumulated_data.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/final_accumulated_data.hpp @@ -6,6 +6,7 @@ #include "aztec3/circuits/abis/membership_witness.hpp" #include "aztec3/circuits/abis/read_request_membership_witness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/constants.hpp" #include "aztec3/utils/types/circuit_types.hpp" #include "aztec3/utils/types/convert.hpp" @@ -30,15 +31,16 @@ template struct FinalAccumulatedData { AggregationObject aggregation_object{}; - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; + // TODO(dbanks12): remove me! std::array nullified_commitments{}; // For pending nullifiers, we have: // nullifiedCommitments[j] != 0 <==> newNullifiers[j] nullifies nullifiedCommitments[j] - std::array private_call_stack{}; - std::array public_call_stack{}; - std::array new_l2_to_l1_msgs{}; + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX> private_call_stack{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX> public_call_stack{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_TX> new_l2_to_l1_msgs{}; std::array encrypted_logs_hash{}; std::array unencrypted_logs_hash{}; @@ -89,13 +91,14 @@ template struct FinalAccumulatedData { aggregation_object.has_data, }, - to_ct(new_commitments), - to_ct(new_nullifiers), + map(new_commitments, to_circuit_type), + map(new_nullifiers, to_circuit_type), + // TODO(dbanks12): remove me! to_ct(nullified_commitments), - to_ct(private_call_stack), - to_ct(public_call_stack), - to_ct(new_l2_to_l1_msgs), + map(private_call_stack, to_circuit_type), + map(public_call_stack, to_circuit_type), + map(new_l2_to_l1_msgs, to_circuit_type), to_ct(encrypted_logs_hash), to_ct(unencrypted_logs_hash), @@ -125,13 +128,14 @@ template struct FinalAccumulatedData { aggregation_object.has_data, }, - to_nt(new_commitments), - to_nt(new_nullifiers), + map(new_commitments, to_native_type), + map(new_nullifiers, to_native_type), + // TODO(dbanks12): remove me! to_nt(nullified_commitments), - to_nt(private_call_stack), - to_nt(public_call_stack), - to_nt(new_l2_to_l1_msgs), + map(private_call_stack, to_native_type), + map(public_call_stack, to_native_type), + map(new_l2_to_l1_msgs, to_native_type), to_nt(encrypted_logs_hash), to_nt(unencrypted_logs_hash), @@ -153,6 +157,7 @@ template struct FinalAccumulatedData { set_array_public(new_commitments); set_array_public(new_nullifiers); + // TODO(dbanks12): remove me! set_array_public(nullified_commitments); set_array_public(private_call_stack); @@ -189,6 +194,31 @@ template struct FinalAccumulatedData { e.set_public(); } } + + // TODO(suyash): We're only making the value public not the counter. Check if this is okay. + template void set_array_public(std::array, SIZE>& arr) + { + static_assert(!(std::is_same::value)); + for (auto& e : arr) { + e.value.set_public(); + } + } + + template void set_array_public(std::array, SIZE>& arr) + { + static_assert(!(std::is_same::value)); + for (auto& e : arr) { + e.value.set_public(); + } + } + + template void set_array_public(std::array, SIZE>& arr) + { + static_assert(!(std::is_same::value)); + for (auto& e : arr) { + e.value.set_public(); + } + } }; } // namespace aztec3::circuits::abis diff --git a/circuits/cpp/src/aztec3/circuits/abis/new_contract_data.hpp b/circuits/cpp/src/aztec3/circuits/abis/new_contract_data.hpp index 8d0a41ffe9b5..c4cedb62523d 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/new_contract_data.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/new_contract_data.hpp @@ -86,12 +86,16 @@ template struct NewContractData { return NCT::compress(inputs, GeneratorIndex::CONTRACT_LEAF); } - void conditional_select(const boolean& condition, const NewContractData& other) + NewContractData static conditional_assign(const boolean& condition, + const NewContractData& lhs, + const NewContractData& rhs) { - contract_address = address::conditional_assign(condition, other.contract_address, contract_address); - portal_contract_address = - address::conditional_assign(condition, other.portal_contract_address, portal_contract_address); - function_tree_root = fr::conditional_assign(condition, other.function_tree_root, function_tree_root); + return NewContractData{ + .contract_address = address::conditional_assign(condition, lhs.contract_address, rhs.contract_address), + .portal_contract_address = + address::conditional_assign(condition, lhs.portal_contract_address, rhs.portal_contract_address), + .function_tree_root = fr::conditional_assign(condition, lhs.function_tree_root, rhs.function_tree_root), + }; } }; diff --git a/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp b/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp index 7894c8bb9d96..3da596f7f819 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp @@ -2,6 +2,7 @@ #include "call_context.hpp" #include "contract_deployment_data.hpp" +#include "side_effects.hpp" #include "aztec3/circuits/abis/historic_block_data.hpp" #include "aztec3/constants.hpp" @@ -11,6 +12,8 @@ #include +#include + namespace aztec3::circuits::abis { using aztec3::utils::types::CircuitTypes; @@ -27,15 +30,16 @@ template class PrivateCircuitPublicInputs { fr args_hash = 0; std::array return_values{}; - std::array read_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> read_requests{}; - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_CALL> new_nullifiers{}; + // TODO(dbanks12): remove me! std::array nullified_commitments{}; - std::array private_call_stack{}; - std::array public_call_stack{}; - std::array new_l2_to_l1_msgs{}; + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL> private_call_stack{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> public_call_stack{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> new_l2_to_l1_msgs{}; std::array encrypted_logs_hash{}; std::array unencrypted_logs_hash{}; @@ -59,6 +63,7 @@ template class PrivateCircuitPublicInputs { read_requests, new_commitments, new_nullifiers, + // TODO(dbanks12): remove me! nullified_commitments, private_call_stack, public_call_stack, @@ -77,9 +82,11 @@ template class PrivateCircuitPublicInputs { return call_context == other.call_context && args_hash == other.args_hash && return_values == other.return_values && read_requests == other.read_requests && new_commitments == other.new_commitments && new_nullifiers == other.new_nullifiers && - nullified_commitments == other.nullified_commitments && private_call_stack == other.private_call_stack && - public_call_stack == other.public_call_stack && new_l2_to_l1_msgs == other.new_l2_to_l1_msgs && - encrypted_logs_hash == other.encrypted_logs_hash && + // TODO(dbanks12): remove me! + nullified_commitments == other.nullified_commitments && + // TODO(dbanks12): ^ remove me! + private_call_stack == other.private_call_stack && public_call_stack == other.public_call_stack && + new_l2_to_l1_msgs == other.new_l2_to_l1_msgs && encrypted_logs_hash == other.encrypted_logs_hash && unencrypted_logs_hash == other.unencrypted_logs_hash && encrypted_log_preimages_length == other.encrypted_log_preimages_length && unencrypted_log_preimages_length == other.unencrypted_log_preimages_length && @@ -103,15 +110,16 @@ template class PrivateCircuitPublicInputs { to_ct(args_hash), to_ct(return_values), - to_ct(read_requests), + map(read_requests, to_circuit_type), - to_ct(new_commitments), - to_ct(new_nullifiers), + map(new_commitments, to_circuit_type), + map(new_nullifiers, to_circuit_type), + // TODO(dbanks12): remove me! to_ct(nullified_commitments), - to_ct(private_call_stack), - to_ct(public_call_stack), - to_ct(new_l2_to_l1_msgs), + map(private_call_stack, to_circuit_type), + map(public_call_stack, to_circuit_type), + map(new_l2_to_l1_msgs, to_circuit_type), to_ct(encrypted_logs_hash), to_ct(unencrypted_logs_hash), @@ -142,15 +150,16 @@ template class PrivateCircuitPublicInputs { to_nt(args_hash), to_nt(return_values), - to_nt(read_requests), + map(read_requests, to_native_type), - to_nt(new_commitments), - to_nt(new_nullifiers), + map(new_commitments, to_native_type), + map(new_nullifiers, to_native_type), + // TODO(dbanks12): remove me! to_nt(nullified_commitments), - to_nt(private_call_stack), - to_nt(public_call_stack), - to_nt(new_l2_to_l1_msgs), + map(private_call_stack, to_native_type), + map(public_call_stack, to_native_type), + map(new_l2_to_l1_msgs, to_native_type), to_nt(encrypted_logs_hash), to_nt(unencrypted_logs_hash), @@ -184,6 +193,7 @@ template class PrivateCircuitPublicInputs { spread_arr_into_vec(new_commitments, inputs); spread_arr_into_vec(new_nullifiers, inputs); + // TODO(dbanks12): remove me! spread_arr_into_vec(nullified_commitments, inputs); spread_arr_into_vec(private_call_stack, inputs); @@ -214,6 +224,15 @@ template class PrivateCircuitPublicInputs { const auto arr_size = sizeof(arr) / sizeof(fr); vec.insert(vec.end(), arr.data(), arr.data() + arr_size); } + + template + void spread_arr_into_vec(std::array const& arr, std::vector& vec) const + { + const auto arr_size = sizeof(arr) / sizeof(fr); + for (size_t i = 0; i < arr_size; i++) { + vec.insert(vec.end(), arr[i].value); + } + } }; // It's been extremely useful for all members here to be std::optional. It allows test app circuits to be very @@ -223,6 +242,9 @@ template class PrivateCircuitPublicInputs { template class OptionalPrivateCircuitPublicInputs { using fr = typename NCT::fr; using opt_fr = typename std::optional; + using opt_se = typename std::optional>; + using opt_se_linked = typename std::optional>; + using opt_se_ranged = typename std::optional>; public: std::optional> call_context; @@ -230,15 +252,16 @@ template class OptionalPrivateCircuitPublicInputs { opt_fr args_hash; std::array return_values; - std::array read_requests; + std::array read_requests; - std::array new_commitments; - std::array new_nullifiers; + std::array new_commitments; + std::array new_nullifiers; + // TODO(dbanks12): remove me! std::array nullified_commitments; - std::array private_call_stack; - std::array public_call_stack; - std::array new_l2_to_l1_msgs; + std::array private_call_stack; + std::array public_call_stack; + std::array new_l2_to_l1_msgs; std::array encrypted_logs_hash; std::array unencrypted_logs_hash; @@ -260,6 +283,7 @@ template class OptionalPrivateCircuitPublicInputs { read_requests, new_commitments, new_nullifiers, + // TODO(dbanks12): remove me! nullified_commitments, private_call_stack, public_call_stack, @@ -281,15 +305,16 @@ template class OptionalPrivateCircuitPublicInputs { opt_fr const& args_hash, std::array const& return_values, - std::array const& read_requests, + std::array const& read_requests, - std::array const& new_commitments, - std::array const& new_nullifiers, + std::array const& new_commitments, + std::array const& new_nullifiers, + // TODO(dbanks12): remove me! std::array const& nullified_commitments, - std::array const& private_call_stack, - std::array const& public_call_stack, - std::array const& new_l2_to_l1_msgs, + std::array const& private_call_stack, + std::array const& public_call_stack, + std::array const& new_l2_to_l1_msgs, std::array const& encrypted_logs_hash, std::array const& unencrypted_logs_hash, @@ -309,6 +334,7 @@ template class OptionalPrivateCircuitPublicInputs { , read_requests(read_requests) , new_commitments(new_commitments) , new_nullifiers(new_nullifiers) + // TODO(dbanks12): remove me! , nullified_commitments(nullified_commitments) , private_call_stack(private_call_stack) , public_call_stack(public_call_stack) @@ -337,6 +363,7 @@ template class OptionalPrivateCircuitPublicInputs { new_inputs.new_commitments.fill(std::nullopt); new_inputs.new_nullifiers.fill(std::nullopt); + // TODO(dbanks12): remove me! new_inputs.nullified_commitments.fill(std::nullopt); new_inputs.private_call_stack.fill(std::nullopt); @@ -359,7 +386,7 @@ template class OptionalPrivateCircuitPublicInputs { return new_inputs; }; - void set_commitments(std::vector commitments) + void set_commitments(std::vector> commitments) { if (commitments.size() > new_commitments.size()) { throw_or_abort("Too many commitments for the number supported by the public inputs ABI."); @@ -369,7 +396,7 @@ template class OptionalPrivateCircuitPublicInputs { } } - void set_nullifiers(std::vector nullifiers) + void set_nullifiers(std::vector> nullifiers) { if (nullifiers.size() > new_nullifiers.size()) { throw_or_abort("Too many commitments for the number supported by the public inputs ABI."); @@ -379,6 +406,7 @@ template class OptionalPrivateCircuitPublicInputs { } } + // TODO(dbanks12): remove me! void set_nullified_commitments(std::vector input_nullified_commitments) { if (input_nullified_commitments.size() > nullified_commitments.size()) { @@ -402,6 +430,7 @@ template class OptionalPrivateCircuitPublicInputs { make_unused_array_elements_zero(builder, new_commitments); make_unused_array_elements_zero(builder, new_nullifiers); + // TODO(dbanks12): remove me! make_unused_array_elements_zero(builder, nullified_commitments); make_unused_array_elements_zero(builder, private_call_stack); @@ -441,6 +470,7 @@ template class OptionalPrivateCircuitPublicInputs { set_array_public(new_commitments); set_array_public(new_nullifiers); + // TODO(dbanks12): remove me! set_array_public(nullified_commitments); set_array_public(private_call_stack); @@ -482,6 +512,7 @@ template class OptionalPrivateCircuitPublicInputs { to_ct(new_commitments), to_ct(new_nullifiers), + // TODO(dbanks12): remove me! to_ct(nullified_commitments), to_ct(private_call_stack), @@ -519,15 +550,16 @@ template class OptionalPrivateCircuitPublicInputs { to_nt(args_hash), to_nt(return_values), - to_nt(read_requests), + map(read_requests, to_native_type), - to_nt(new_commitments), - to_nt(new_nullifiers), + map(new_commitments, to_native_type), + map(new_nullifiers, to_native_type), + // TODO(dbanks12): remove me! to_nt(nullified_commitments), - to_nt(private_call_stack), - to_nt(public_call_stack), - to_nt(new_l2_to_l1_msgs), + map(private_call_stack, to_native_type), + map(public_call_stack, to_native_type), + map(new_l2_to_l1_msgs, to_native_type), to_nt(encrypted_logs_hash), to_nt(unencrypted_logs_hash), @@ -565,6 +597,7 @@ template class OptionalPrivateCircuitPublicInputs { spread_arr_opt_into_vec(new_commitments, inputs); spread_arr_opt_into_vec(new_nullifiers, inputs); + // TODO(dbanks12): remove me! spread_arr_opt_into_vec(nullified_commitments, inputs); spread_arr_opt_into_vec(private_call_stack, inputs); @@ -602,6 +635,7 @@ template class OptionalPrivateCircuitPublicInputs { .new_commitments = map(new_commitments, get_value), .new_nullifiers = map(new_nullifiers, get_value), + // TODO(dbanks12): remove me! .nullified_commitments = map(nullified_commitments, get_value), .private_call_stack = map(private_call_stack, get_value), @@ -626,24 +660,25 @@ template class OptionalPrivateCircuitPublicInputs { private: bool all_elements_populated = false; - template - void spread_arr_opt_into_vec(std::array, SIZE> const& arr, std::vector& vec) const + template + void spread_arr_opt_into_vec(std::array, SIZE> const& arr, std::vector& vec) const { - auto get_opt_value = [](const std::optional& e) { + auto get_opt_value = [](const std::optional& e) { if (!e) { throw_or_abort("Value is nullopt"); } return *e; }; - std::array arr_values = map(arr, get_opt_value); - const auto arr_size = sizeof(arr_values) / sizeof(fr); + std::array arr_values = map(arr, get_opt_value); + const auto arr_size = sizeof(arr_values) / sizeof(SE); vec.insert(vec.end(), arr_values.data(), arr_values.data() + arr_size); } - template void spread_arr_into_vec(std::array const& arr, std::vector& vec) const + template + void spread_arr_into_vec(std::array const& arr, std::vector& vec) const { - const auto arr_size = sizeof(arr) / sizeof(fr); + const auto arr_size = sizeof(arr) / sizeof(SE); vec.insert(vec.end(), arr.data(), arr.data() + arr_size); } @@ -688,5 +723,29 @@ template class OptionalPrivateCircuitPublicInputs { fr(*e).set_public(); } } + + // We need the following functions for SideEffect* data types because a side-effect object contains: + // (value, counter, ...) + // TODO(suyash): Decide if we want to make counters, etc public. + template void set_array_public(std::array>, SIZE>& arr) + { + for (std::optional>& e : arr) { + fr((*e).value).set_public(); + } + } + + template void set_array_public(std::array>, SIZE>& arr) + { + for (std::optional>& e : arr) { + fr((*e).value).set_public(); + } + } + + template void set_array_public(std::array>, SIZE>& arr) + { + for (std::optional>& e : arr) { + fr((*e).value).set_public(); + } + } }; } // namespace aztec3::circuits::abis diff --git a/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp b/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp index 75d2b804020d..0328634a0bfc 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp @@ -6,6 +6,7 @@ #include "../../constants.hpp" #include "aztec3/circuits/abis/historic_block_data.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/utils/types/circuit_types.hpp" #include "aztec3/utils/types/native_types.hpp" @@ -31,10 +32,10 @@ template struct PublicCircuitPublicInputs { contract_storage_update_requests{}; std::array, MAX_PUBLIC_DATA_READS_PER_CALL> contract_storage_reads{}; - std::array public_call_stack{}; - std::array new_commitments{}; - std::array new_nullifiers{}; - std::array new_l2_to_l1_msgs{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> public_call_stack{}; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_CALL> new_nullifiers{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> new_l2_to_l1_msgs{}; std::array unencrypted_logs_hash{}; @@ -83,10 +84,10 @@ template struct PublicCircuitPublicInputs { .contract_storage_update_requests = map(contract_storage_update_requests, to_circuit_type), .contract_storage_reads = map(contract_storage_reads, to_circuit_type), - .public_call_stack = to_ct(public_call_stack), - .new_commitments = to_ct(new_commitments), - .new_nullifiers = to_ct(new_nullifiers), - .new_l2_to_l1_msgs = to_ct(new_l2_to_l1_msgs), + .public_call_stack = map(public_call_stack, to_circuit_type), + .new_commitments = map(new_commitments, to_circuit_type), + .new_nullifiers = map(new_nullifiers, to_circuit_type), + .new_l2_to_l1_msgs = map(new_l2_to_l1_msgs, to_circuit_type), .unencrypted_logs_hash = to_ct(unencrypted_logs_hash), .unencrypted_log_preimages_length = to_ct(unencrypted_log_preimages_length), @@ -135,6 +136,16 @@ template struct PublicCircuitPublicInputs { const auto arr_size = sizeof(arr) / sizeof(fr); vec.insert(vec.end(), arr.data(), arr.data() + arr_size); } + + template + void spread_arr_into_vec(std::array const& arr, std::vector& vec) const + { + const auto arr_size = sizeof(arr) / sizeof(fr); + for (size_t i = 0; i < arr_size; i++) { + vec.insert(vec.end(), arr[i].value); + } + } + }; // namespace aztec3::circuits::abis } // namespace aztec3::circuits::abis diff --git a/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp b/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp new file mode 100644 index 000000000000..1c4fbe5c8616 --- /dev/null +++ b/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp @@ -0,0 +1,252 @@ +#pragma once + +#include "aztec3/utils/types/circuit_types.hpp" +#include "aztec3/utils/types/convert.hpp" +#include "aztec3/utils/types/native_types.hpp" + +namespace aztec3::circuits::abis { + +using aztec3::utils::types::CircuitTypes; +using aztec3::utils::types::NativeTypes; + +// template +// void spread_struct_arr_into_vec(std::array const& arr, std::vector& vec) +//{ +// const auto arr_size = sizeof(arr) / sizeof(SE); +// vec.insert(vec.end(), arr.data, arr.data() + arr_size); +// } + +template struct SideEffect { + using fr = typename NCT::fr; + using boolean = typename NCT::boolean; + + fr value = 0; + fr side_effect_counter = 0; + + // For serialization, update with new fields + MSGPACK_FIELDS(value, side_effect_counter); + boolean operator==(SideEffect const& other) const + { + return value == other.value && side_effect_counter == other.side_effect_counter; + }; + + template SideEffect> to_circuit_type(Builder& builder) const + { + static_assert((std::is_same::value)); + + // Capture the circuit builder: + auto to_ct = [&](auto& e) { return aztec3::utils::types::to_ct(builder, e); }; + + SideEffect> side_effect = { + to_ct(value), + to_ct(side_effect_counter), + }; + + return side_effect; + }; + + template SideEffect to_native_type() const + { + static_assert((std::is_same, NCT>::value)); + auto to_nt = [&](auto& e) { return aztec3::utils::types::to_nt(e); }; + + SideEffect side_effect = { + to_nt(value), + to_nt(side_effect_counter), + }; + + return side_effect; + }; + + SideEffect static conditional_assign(boolean const& predicate, + SideEffect const& lhs, + SideEffect const& rhs) + { + return SideEffect{ + fr::conditional_assign(predicate, lhs.value, rhs.value), + fr::conditional_assign(predicate, lhs.side_effect_counter, rhs.side_effect_counter), + }; + } + + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? + template void assert_is_zero() + { + static_assert((std::is_same, NCT>::value)); + + value.assert_is_zero(); + side_effect_counter.assert_is_zero(); + } + + boolean is_empty() const { return ((value.is_zero()) && (side_effect_counter.is_zero())); } + + void set_public() + { + static_assert(!(std::is_same::value)); + + value.set_public(); + side_effect_counter.set_public(); + } +}; + +template struct SideEffectLinkedToNoteHash { + using fr = typename NCT::fr; + using boolean = typename NCT::boolean; + + fr value = 0; + fr note_hash = 0; + fr side_effect_counter = 0; + + // For serialization, update with new fields + MSGPACK_FIELDS(value, note_hash, side_effect_counter); + boolean operator==(SideEffectLinkedToNoteHash const& other) const + { + return value == other.value && note_hash == other.note_hash && side_effect_counter == other.side_effect_counter; + }; + + template + SideEffectLinkedToNoteHash> to_circuit_type(Builder& builder) const + { + static_assert((std::is_same::value)); + + // Capture the circuit builder: + auto to_ct = [&](auto& e) { return aztec3::utils::types::to_ct(builder, e); }; + + SideEffectLinkedToNoteHash> side_effect = { + to_ct(value), + to_ct(note_hash), + to_ct(side_effect_counter), + }; + + return side_effect; + }; + + template SideEffectLinkedToNoteHash to_native_type() const + { + static_assert((std::is_same, NCT>::value)); + auto to_nt = [&](auto& e) { return aztec3::utils::types::to_nt(e); }; + + SideEffectLinkedToNoteHash side_effect = { + to_nt(value), + to_nt(note_hash), + to_nt(side_effect_counter), + }; + + return side_effect; + }; + + SideEffectLinkedToNoteHash static conditional_assign(boolean const& predicate, + SideEffectLinkedToNoteHash const& lhs, + SideEffectLinkedToNoteHash const& rhs) + { + return SideEffectLinkedToNoteHash{ + fr::conditional_assign(predicate, lhs.value, rhs.value), + fr::conditional_assign(predicate, lhs.note_hash, rhs.note_hash), + fr::conditional_assign(predicate, lhs.side_effect_counter, rhs.side_effect_counter), + }; + } + + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? + template void assert_is_zero() + { + static_assert((std::is_same, NCT>::value)); + + value.assert_is_zero(); + note_hash.assert_is_zero(); + side_effect_counter.assert_is_zero(); + } + + boolean is_empty() const { return ((value.is_zero()) && (note_hash.is_zero()) && (side_effect_counter.is_zero())); } + + void set_public() + { + static_assert(!(std::is_same::value)); + + value.set_public(); + note_hash.set_public(); + side_effect_counter.set_public(); + } +}; + +template struct SideEffectWithRange { + using fr = typename NCT::fr; + using boolean = typename NCT::boolean; + + fr value = 0; + fr start_side_effect_counter = 0; + fr end_side_effect_counter = 0; + + // For serialization, update with new fields + MSGPACK_FIELDS(value, start_side_effect_counter, end_side_effect_counter); + boolean operator==(SideEffectWithRange const& other) const + { + return value == other.value && start_side_effect_counter == other.start_side_effect_counter && + end_side_effect_counter == other.end_side_effect_counter; + }; + + template SideEffectWithRange> to_circuit_type(Builder& builder) const + { + static_assert((std::is_same::value)); + + // Capture the circuit builder: + auto to_ct = [&](auto& e) { return aztec3::utils::types::to_ct(builder, e); }; + + SideEffectWithRange> side_effect = { + to_ct(value), + to_ct(start_side_effect_counter), + to_ct(end_side_effect_counter), + }; + + return side_effect; + }; + + template SideEffectWithRange to_native_type() const + { + static_assert((std::is_same, NCT>::value)); + auto to_nt = [&](auto& e) { return aztec3::utils::types::to_nt(e); }; + + SideEffectWithRange side_effect = { + to_nt(value), + to_nt(start_side_effect_counter), + to_nt(end_side_effect_counter), + }; + + return side_effect; + }; + + SideEffectWithRange static conditional_assign(boolean const& predicate, + SideEffectWithRange const& lhs, + SideEffectWithRange const& rhs) + { + return SideEffectWithRange{ + fr::conditional_assign(predicate, lhs.value, rhs.value), + fr::conditional_assign(predicate, lhs.start_side_effect_counter, rhs.start_side_effect_counter), + fr::conditional_assign(predicate, lhs.end_side_effect_counter, rhs.end_side_effect_counter), + }; + } + + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? + template void assert_is_zero() + { + static_assert((std::is_same, NCT>::value)); + + value.assert_is_zero(); + start_side_effect_counter.assert_is_zero(); + end_side_effect_counter.assert_is_zero(); + } + + boolean is_empty() const + { + return ((value.is_zero()) && (start_side_effect_counter.is_zero()) && (end_side_effect_counter.is_zero())); + } + + void set_public() + { + static_assert(!(std::is_same::value)); + + value.set_public(); + start_side_effect_counter.set_public(); + end_side_effect_counter.set_public(); + } +}; + +} // namespace aztec3::circuits::abis \ No newline at end of file diff --git a/circuits/cpp/src/aztec3/circuits/abis/tx_request.hpp b/circuits/cpp/src/aztec3/circuits/abis/tx_request.hpp index de01c08e2793..f31257b9a1a1 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/tx_request.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/tx_request.hpp @@ -6,7 +6,7 @@ #include "aztec3/utils/types/convert.hpp" #include "aztec3/utils/types/native_types.hpp" -#include +// #include namespace aztec3::circuits::abis { diff --git a/circuits/cpp/src/aztec3/circuits/apps/function_execution_context.hpp b/circuits/cpp/src/aztec3/circuits/apps/function_execution_context.hpp index ad1b597f4ba1..a31d23e36939 100644 --- a/circuits/cpp/src/aztec3/circuits/apps/function_execution_context.hpp +++ b/circuits/cpp/src/aztec3/circuits/apps/function_execution_context.hpp @@ -8,11 +8,14 @@ #include "aztec3/circuits/abis/call_stack_item.hpp" #include "aztec3/circuits/abis/function_data.hpp" #include "aztec3/circuits/abis/private_circuit_public_inputs.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/abis/types.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/constants.hpp" +#include "aztec3/utils/array.hpp" #include "aztec3/utils/types/convert.hpp" +#include "barretenberg/common/map.hpp" #include namespace aztec3::circuits::apps { @@ -22,6 +25,8 @@ using aztec3::circuits::abis::FunctionData; using aztec3::circuits::abis::OptionalPrivateCircuitPublicInputs; using aztec3::circuits::abis::PrivateCircuitPublicInputs; using aztec3::circuits::abis::PrivateTypes; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; using aztec3::circuits::apps::notes::NoteInterface; using aztec3::circuits::apps::opcodes::Opcodes; @@ -246,7 +251,12 @@ template class FunctionExecutionContext { auto call_stack_item_hash = f_call_stack_item_ct.hash(); - array_push(private_circuit_public_inputs.private_call_stack, call_stack_item_hash); + // TODO(suyash): Counters are set to 0 for now. + auto call_stack_item_se = abis::SideEffectWithRange{ .value = call_stack_item_hash, + .start_side_effect_counter = 0, + .end_side_effect_counter = 0 }; + + utils::aztec_circuit_array_push(private_circuit_public_inputs.private_call_stack, call_stack_item_se); // The return values are implicitly constrained by being returned as circuit types from this method, for // further use in the circuit. Note: ALL elements of the return_values array MUST be constrained, even if @@ -322,8 +332,12 @@ template class FunctionExecutionContext { void finalise() { finalise_utxos(); - private_circuit_public_inputs.set_commitments(new_commitments); - private_circuit_public_inputs.set_nullifiers(new_nullifiers); + auto to_se_arr = [&](auto& val) { return SideEffect{ val, 0 }; }; + auto to_se_linked_arr = [&](auto& val) { return SideEffectLinkedToNoteHash{ val, 0, 0 }; }; + + private_circuit_public_inputs.set_commitments(map(new_commitments, to_se_arr)); + private_circuit_public_inputs.set_nullifiers(map(new_nullifiers, to_se_linked_arr)); + // TODO(dbanks12): remove me! private_circuit_public_inputs.set_nullified_commitments(nullified_commitments); private_circuit_public_inputs.set_public(builder); final_private_circuit_public_inputs = diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/common.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/common.cpp index 97b92d1f8c74..bb3e582fa388 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/common.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/common.cpp @@ -8,6 +8,7 @@ #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_call_data.hpp" #include "aztec3/circuits/abis/read_request_membership_witness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/constants.hpp" #include "aztec3/utils/array.hpp" @@ -21,6 +22,8 @@ using aztec3::circuits::abis::FunctionData; using aztec3::circuits::abis::KernelCircuitPublicInputs; using aztec3::circuits::abis::NewContractData; using aztec3::circuits::abis::ReadRequestMembershipWitness; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; using aztec3::utils::array_push; using aztec3::utils::is_array_empty; @@ -36,7 +39,7 @@ void common_validate_call_stack(DummyBuilder& builder, PrivateCallData const const auto& stack = private_call.call_stack_item.public_inputs.private_call_stack; const auto& preimages = private_call.private_call_stack_preimages; for (size_t i = 0; i < stack.size(); ++i) { - const auto& hash = stack[i]; + const auto& hash = stack[i].value; const auto& preimage = preimages[i]; // Note: this assumes it's computationally infeasible to have `0` as a valid call_stack_item_hash. @@ -67,14 +70,14 @@ void common_validate_call_stack(DummyBuilder& builder, PrivateCallData const */ void common_validate_read_requests(DummyBuilder& builder, NT::fr const& historic_private_data_tree_root, - std::array const& read_requests, + std::array, MAX_READ_REQUESTS_PER_CALL> const& read_requests, std::array, MAX_READ_REQUESTS_PER_CALL> const& read_request_membership_witnesses) { // membership witnesses must resolve to the same private data root // for every request in all kernel iterations for (size_t rr_idx = 0; rr_idx < aztec3::MAX_READ_REQUESTS_PER_CALL; rr_idx++) { - const auto& read_request = read_requests[rr_idx]; + const auto& read_request = read_requests[rr_idx].value; const auto& witness = read_request_membership_witnesses[rr_idx]; // A pending commitment is the one that is not yet added to private data tree @@ -147,8 +150,12 @@ void common_update_end_values(DummyBuilder& builder, const auto& read_request = read_requests[i]; const auto& witness = read_request_membership_witnesses[i]; if (witness.is_transient) { // only forward transient to public inputs - const auto siloed_read_request = - read_request == 0 ? 0 : silo_commitment(storage_contract_address, read_request); + const auto siloed_read_request_value = + read_request.value == 0 ? 0 : silo_commitment(storage_contract_address, read_request.value); + const auto siloed_read_request = SideEffect{ + .value = siloed_read_request_value, + .side_effect_counter = read_request.side_effect_counter, + }; array_push(builder, public_inputs.end.read_requests, siloed_read_request, @@ -161,10 +168,19 @@ void common_update_end_values(DummyBuilder& builder, // Enhance commitments and nullifiers with domain separation whereby domain is the contract. { // nullifiers - std::array siloed_new_nullifiers{}; + std::array, MAX_NEW_NULLIFIERS_PER_CALL> siloed_new_nullifiers{}; for (size_t i = 0; i < MAX_NEW_NULLIFIERS_PER_CALL; ++i) { - siloed_new_nullifiers[i] = - new_nullifiers[i] == 0 ? 0 : silo_nullifier(storage_contract_address, new_nullifiers[i]); + const auto& nullifier = new_nullifiers[i]; + + const auto& siloed_note_hash = nullifier.note_hash == fr(0) ? fr(0) // don't silo when empty + : nullifier.note_hash == fr(EMPTY_NULLIFIED_COMMITMENT) + ? fr(EMPTY_NULLIFIED_COMMITMENT) // don't silo when empty + : silo_commitment(storage_contract_address, nullifier.note_hash); + siloed_new_nullifiers[i] = SideEffectLinkedToNoteHash{ + .value = nullifier.value == 0 ? 0 : silo_nullifier(storage_contract_address, nullifier.value), + .note_hash = siloed_note_hash, + .side_effect_counter = nullifier.side_effect_counter, + }; } push_array_to_array( builder, @@ -173,10 +189,13 @@ void common_update_end_values(DummyBuilder& builder, format(PRIVATE_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "too many new nullifiers in one tx")); // commitments - std::array siloed_new_commitments{}; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> siloed_new_commitments{}; for (size_t i = 0; i < new_commitments.size(); ++i) { - siloed_new_commitments[i] = - new_commitments[i] == 0 ? 0 : silo_commitment(storage_contract_address, new_commitments[i]); + const auto& commitment = new_commitments[i]; + siloed_new_commitments[i] = SideEffect{ + .value = commitment.value == 0 ? 0 : silo_commitment(storage_contract_address, commitment.value), + .side_effect_counter = commitment.side_effect_counter, + }; } push_array_to_array( builder, @@ -184,6 +203,7 @@ void common_update_end_values(DummyBuilder& builder, public_inputs.end.new_commitments, format(PRIVATE_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "too many new commitments in one tx")); + // TODO(dbanks12): remove me! // nullified commitments (for matching transient nullifiers to transient commitments) // Since every new_nullifiers entry is paired with a nullified_commitment, EMPTY // is used here for nullified_commitments of persistable nullifiers. EMPTY will still @@ -225,14 +245,18 @@ void common_update_end_values(DummyBuilder& builder, { // new l2 to l1 messages const auto& portal_contract_address = private_call.portal_contract_address; const auto& new_l2_to_l1_msgs = private_call_public_inputs.new_l2_to_l1_msgs; - std::array new_l2_to_l1_msgs_to_insert{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> new_l2_to_l1_msgs_to_insert{}; for (size_t i = 0; i < new_l2_to_l1_msgs.size(); ++i) { - if (!new_l2_to_l1_msgs[i].is_zero()) { - new_l2_to_l1_msgs_to_insert[i] = compute_l2_to_l1_hash(storage_contract_address, - private_call_public_inputs.version, - portal_contract_address, - private_call_public_inputs.chain_id, - new_l2_to_l1_msgs[i]); + const auto& msg = new_l2_to_l1_msgs[i]; + if (!msg.value.is_zero()) { + new_l2_to_l1_msgs_to_insert[i] = { + .value = compute_l2_to_l1_hash(storage_contract_address, + private_call_public_inputs.version, + portal_contract_address, + private_call_public_inputs.chain_id, + msg.value), + .side_effect_counter = msg.side_effect_counter, + }; } } push_array_to_array( @@ -319,7 +343,11 @@ void common_contract_logic(DummyBuilder& builder, // push the contract address nullifier to nullifier vector array_push(builder, public_inputs.end.new_nullifiers, - new_contract_address_nullifier, + SideEffectLinkedToNoteHash{ + .value = new_contract_address_nullifier, + .note_hash = NT::fr(EMPTY_NULLIFIED_COMMITMENT), + .side_effect_counter = NT::fr(99999999), // TODO(dbanks12): assign se counter to new contract? + }, format(PRIVATE_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "too many nullifiers in one tx to add the new contract address")); } else { diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/common.hpp b/circuits/cpp/src/aztec3/circuits/kernel/private/common.hpp index 52e26279d7b5..c35d3f019086 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/common.hpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/common.hpp @@ -8,6 +8,7 @@ #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_call_data.hpp" #include "aztec3/circuits/abis/read_request_membership_witness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/utils/dummy_circuit_builder.hpp" @@ -18,6 +19,7 @@ using aztec3::circuits::abis::FunctionData; using aztec3::circuits::abis::KernelCircuitPublicInputs; using aztec3::circuits::abis::PreviousKernelData; using aztec3::circuits::abis::ReadRequestMembershipWitness; +using aztec3::circuits::abis::SideEffect; using aztec3::circuits::abis::private_kernel::PrivateCallData; using DummyBuilder = aztec3::utils::DummyCircuitBuilder; @@ -28,7 +30,7 @@ void common_validate_call_stack(DummyBuilder& builder, PrivateCallData const void common_validate_read_requests(DummyBuilder& builder, NT::fr const& historic_private_data_tree_root, - std::array const& read_requests, + std::array, MAX_READ_REQUESTS_PER_CALL> const& read_requests, std::array, MAX_READ_REQUESTS_PER_CALL> const& read_request_membership_witnesses); diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit.test.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit.test.cpp index f9e0aef3d2f6..60f5942cb014 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit.test.cpp @@ -54,8 +54,8 @@ TEST_F(native_private_kernel_tests, native_accumulate_transient_read_requests) { auto private_inputs_init = do_private_call_get_kernel_inputs_init(false, deposit, standard_test_args()); - private_inputs_init.private_call.call_stack_item.public_inputs.new_commitments[0] = fr(12); - private_inputs_init.private_call.call_stack_item.public_inputs.read_requests[0] = fr(23); + private_inputs_init.private_call.call_stack_item.public_inputs.new_commitments[0].value = fr(12); + private_inputs_init.private_call.call_stack_item.public_inputs.read_requests[0].value = fr(23); private_inputs_init.private_call.read_request_membership_witnesses[0].is_transient = true; std::array read_commitment_hints{}; @@ -71,15 +71,15 @@ TEST_F(native_private_kernel_tests, native_accumulate_transient_read_requests) auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0] = fr(23); - private_inputs_inner.private_call.call_stack_item.public_inputs.read_requests[0] = fr(12); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0].value = fr(23); + private_inputs_inner.private_call.call_stack_item.public_inputs.read_requests[0].value = fr(12); private_inputs_inner.private_call.read_request_membership_witnesses[0].is_transient = true; read_commitment_hints[1] = fr(0); // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the new_commitments and read_requests of the current_call_stack_item's public_inputs - private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs_inner.private_call.call_stack_item.hash(); // The original call is not multi-iterative (call stack depth == 1) and we re-feed the same private call stack @@ -111,8 +111,8 @@ TEST_F(native_private_kernel_tests, native_transient_read_requests_no_match) { auto private_inputs_init = do_private_call_get_kernel_inputs_init(false, deposit, standard_test_args()); - private_inputs_init.private_call.call_stack_item.public_inputs.new_commitments[0] = fr(10); - private_inputs_init.private_call.call_stack_item.public_inputs.read_requests[0] = fr(23); + private_inputs_init.private_call.call_stack_item.public_inputs.new_commitments[0].value = fr(10); + private_inputs_init.private_call.call_stack_item.public_inputs.read_requests[0].value = fr(23); private_inputs_init.private_call.read_request_membership_witnesses[0].is_transient = true; std::array read_commitment_hints{}; @@ -128,15 +128,15 @@ TEST_F(native_private_kernel_tests, native_transient_read_requests_no_match) auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0] = fr(23); - private_inputs_inner.private_call.call_stack_item.public_inputs.read_requests[0] = fr(12); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0].value = fr(23); + private_inputs_inner.private_call.call_stack_item.public_inputs.read_requests[0].value = fr(12); private_inputs_inner.private_call.read_request_membership_witnesses[0].is_transient = true; read_commitment_hints[1] = fr(0); // There is not correct possible value. // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the new_commitments and read_requests of the current_call_stack_item's public_inputs - private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs_inner.private_call.call_stack_item.hash(); // The original call is not multi-iterative (call stack depth == 1) and we re-feed the same private call stack @@ -167,18 +167,18 @@ TEST_F(native_private_kernel_tests, native_empty_nullified_commitment_respected) { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0] = fr(23); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[1] = fr(33); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[0].value = fr(23); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_commitments[1].value = fr(33); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_nullifiers[0] = fr(11); - private_inputs_inner.private_call.call_stack_item.public_inputs.new_nullifiers[1] = fr(18); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_nullifiers[0].value = fr(11); + private_inputs_inner.private_call.call_stack_item.public_inputs.new_nullifiers[1].value = fr(18); private_inputs_inner.private_call.call_stack_item.public_inputs.nullified_commitments[0] = fr(EMPTY_NULLIFIED_COMMITMENT); private_inputs_inner.private_call.call_stack_item.public_inputs.nullified_commitments[1] = fr(33); // update the private call stack contents to reflect the above changes which affect the item hash - private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs_inner.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs_inner.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_tests__native_empty_nullified_commitment_respected"); diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.cpp index 53df785c2887..fe9514ab2ecd 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.cpp @@ -4,6 +4,7 @@ #include "aztec3/circuits/abis/combined_constant_data.hpp" #include "aztec3/circuits/abis/historic_block_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_kernel_inputs_init.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/constants.hpp" #include "aztec3/utils/array.hpp" @@ -13,6 +14,7 @@ using NT = aztec3::utils::types::NativeTypes; using aztec3::circuits::abis::CombinedConstantData; using aztec3::circuits::abis::KernelCircuitPublicInputs; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; using aztec3::circuits::abis::private_kernel::PrivateKernelInputsInit; using aztec3::utils::array_push; using aztec3::utils::CircuitErrorCode; @@ -125,13 +127,17 @@ void update_end_values(DummyCircuitBuilder& builder, KernelCircuitPublicInputs& public_inputs) { // We only initialized constants member of public_inputs so far. Therefore, there must not be any - // new nullifiers or logs as part of public_inputs. + // new nullifiers, logs, etc as part of public_inputs. + builder.do_assert(is_array_empty(public_inputs.end.read_requests), + "public_inputs.end.read_requests must start as empty in initial kernel iteration", + CircuitErrorCode::PRIVATE_KERNEL__UNSUPPORTED_OP); builder.do_assert(is_array_empty(public_inputs.end.new_commitments), "public_inputs.end.new_commitments must start as empty in initial kernel iteration", CircuitErrorCode::PRIVATE_KERNEL__UNSUPPORTED_OP); builder.do_assert(is_array_empty(public_inputs.end.new_nullifiers), "public_inputs.end.new_nullifiers must start as empty in initial kernel iteration", CircuitErrorCode::PRIVATE_KERNEL__UNSUPPORTED_OP); + // TODO(dbanks12): remove me! builder.do_assert(is_array_empty(public_inputs.end.nullified_commitments), "public_inputs.end.nullified_commitments must start as empty in initial kernel iteration", CircuitErrorCode::PRIVATE_KERNEL__UNSUPPORTED_OP); @@ -154,9 +160,14 @@ void update_end_values(DummyCircuitBuilder& builder, // Since it's the first iteration, we need to push the the tx hash nullifier into the `new_nullifiers` array array_push(builder, public_inputs.end.new_nullifiers, - private_inputs.tx_request.hash(), + SideEffectLinkedToNoteHash{ + .value = private_inputs.tx_request.hash(), + .note_hash = NT::fr(EMPTY_NULLIFIED_COMMITMENT), + .side_effect_counter = NT::fr(0), + }, format(PRIVATE_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "could not push tx hash nullifier into new_nullifiers array. Too many new nullifiers in one tx")); + // TODO(dbanks12): remove me! // Push an empty nullified commitment too since each nullifier must // be paired with a nonzero (real or "empty") nullified commitment array_push(builder, @@ -213,8 +224,8 @@ KernelCircuitPublicInputs native_private_kernel_circuit_initial(DummyCircuit // TODO(dbanks12): kernel vk membership check! - // In the native version, as there is no verify_proofs call, we can initialize aggregation object with the default - // constructor. + // In the native version, as there is no verify_proofs call, we can initialize aggregation object with the + // default constructor. NT::AggregationObject const empty_aggregation_object{}; public_inputs.end.aggregation_object = empty_aggregation_object; diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.test.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.test.cpp index d1fecdf67452..1a7b34a41b4a 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_init.test.cpp @@ -1,6 +1,7 @@ #include "testing_harness.hpp" #include "aztec3/circuits/abis/read_request_membership_witness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/apps/test_apps/basic_contract_deployment/basic_contract_deployment.hpp" #include "aztec3/circuits/apps/test_apps/escrow/deposit.hpp" #include "aztec3/circuits/hash.hpp" @@ -69,7 +70,7 @@ TEST_F(native_private_kernel_init_tests, deposit) EXPECT_TRUE(validate_no_new_deployed_contract(public_inputs)); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); // Log preimages length should increase by `(un)encrypted_log_preimages_length` from private input ASSERT_EQ(public_inputs.end.encrypted_log_preimages_length, encrypted_log_preimages_length); @@ -123,7 +124,7 @@ TEST_F(native_private_kernel_init_tests, DISABLED_contract_deployment_call_stack auto private_inputs = do_private_call_get_kernel_inputs_init(true, constructor, standard_test_args()); // Randomise the second item in the private call stack (i.e. hash of the private call item). - private_inputs.private_call.call_stack_item.public_inputs.private_call_stack[1] = NT::fr::random_element(); + private_inputs.private_call.call_stack_item.public_inputs.private_call_stack[1].value = NT::fr::random_element(); DummyBuilder builder = DummyBuilder("private_kernel_tests__contract_deployment_call_stack_item_hash_mismatch_fails"); @@ -319,7 +320,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_bad_request) private_inputs.private_call.call_stack_item.public_inputs.historic_block_data.private_data_tree_root = root; // tweak read_request so it gives wrong root when paired with its sibling path - read_requests[1] += 1; + read_requests[1].value += 1; private_inputs.private_call.call_stack_item.public_inputs.read_requests = read_requests; private_inputs.private_call.read_request_membership_witnesses = read_request_membership_witnesses; @@ -334,7 +335,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_bad_request) CircuitErrorCode::PRIVATE_KERNEL__READ_REQUEST_PRIVATE_DATA_ROOT_MISMATCH); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); } TEST_F(native_private_kernel_init_tests, native_read_request_bad_leaf_index) @@ -367,7 +368,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_bad_leaf_index) CircuitErrorCode::PRIVATE_KERNEL__READ_REQUEST_PRIVATE_DATA_ROOT_MISMATCH); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); } TEST_F(native_private_kernel_init_tests, native_read_request_bad_sibling_path) @@ -400,7 +401,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_bad_sibling_path) CircuitErrorCode::PRIVATE_KERNEL__READ_REQUEST_PRIVATE_DATA_ROOT_MISMATCH); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); } TEST_F(native_private_kernel_init_tests, native_read_request_root_mismatch) @@ -423,7 +424,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_root_mismatch) _transient_read_requests1, _transient_read_request_membership_witnesses1, _root] = get_random_reads(first_nullifier, contract_address, 2); - std::array bad_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> bad_requests{}; std::array, MAX_READ_REQUESTS_PER_CALL> bad_witnesses; // note we are using read_requests0 for some and read_requests1 for others bad_requests[0] = read_requests0[0]; @@ -447,7 +448,7 @@ TEST_F(native_private_kernel_init_tests, native_read_request_root_mismatch) CircuitErrorCode::PRIVATE_KERNEL__READ_REQUEST_PRIVATE_DATA_ROOT_MISMATCH); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); } TEST_F(native_private_kernel_init_tests, native_no_read_requests_works) @@ -457,7 +458,7 @@ TEST_F(native_private_kernel_init_tests, native_no_read_requests_works) auto private_inputs = do_private_call_get_kernel_inputs_init(false, deposit, standard_test_args()); // empty requests - std::array const read_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> const read_requests{}; std::array, MAX_READ_REQUESTS_PER_CALL> const read_request_membership_witnesses{}; private_inputs.private_call.call_stack_item.public_inputs.read_requests = read_requests; @@ -475,7 +476,7 @@ TEST_F(native_private_kernel_init_tests, native_no_read_requests_works) ASSERT_FALSE(builder.failed()); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); // non-transient read requests are NOT forwarded ASSERT_EQ(array_length(public_inputs.end.read_requests), 0); @@ -512,7 +513,7 @@ TEST_F(native_private_kernel_init_tests, native_one_read_requests_works) ASSERT_FALSE(builder.failed()); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); // non-transient read requests are NOT forwarded ASSERT_EQ(array_length(public_inputs.end.read_requests), 0); @@ -549,7 +550,7 @@ TEST_F(native_private_kernel_init_tests, native_two_read_requests_works) ASSERT_FALSE(builder.failed()); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); // non-transient read requests are NOT forwarded ASSERT_EQ(array_length(public_inputs.end.read_requests), 0); @@ -586,7 +587,7 @@ TEST_F(native_private_kernel_init_tests, native_max_read_requests_works) ASSERT_FALSE(builder.failed()); // Check the first nullifier is hash of the signed tx request - ASSERT_EQ(public_inputs.end.new_nullifiers[0], private_inputs.tx_request.hash()); + ASSERT_EQ(public_inputs.end.new_nullifiers[0].value, private_inputs.tx_request.hash()); // non-transient read requests are NOT forwarded ASSERT_EQ(array_length(public_inputs.end.read_requests), 0); diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.cpp index fa8337b6656f..7c2957a67af4 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.cpp @@ -5,6 +5,7 @@ #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_kernel_inputs_inner.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/utils/array.hpp" #include "aztec3/utils/dummy_circuit_builder.hpp" @@ -14,6 +15,7 @@ using NT = aztec3::utils::types::NativeTypes; using aztec3::circuits::abis::ContractLeafPreimage; using aztec3::circuits::abis::KernelCircuitPublicInputs; using aztec3::circuits::abis::PreviousKernelData; +using aztec3::circuits::abis::SideEffectWithRange; using aztec3::circuits::abis::private_kernel::PrivateKernelInputsInner; using aztec3::circuits::kernel::private_kernel::common_initialise_end_values; using aztec3::utils::array_length; @@ -58,11 +60,11 @@ namespace aztec3::circuits::kernel::private_kernel { void pop_and_validate_this_private_call_hash( DummyCircuitBuilder& builder, PrivateCallData const& private_call, - std::array& private_call_stack) + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX>& private_call_stack) { // TODO(mike): this logic might need to change to accommodate the weird edge 3 initial txs (the 'main' tx, the // 'fee' tx, and the 'gas rebate' tx). - const auto popped_private_call_hash = array_pop(private_call_stack); + const auto popped_private_call_hash = array_pop(private_call_stack).value; const auto calculated_this_private_call_hash = private_call.call_stack_item.hash(); builder.do_assert( diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.test.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.test.cpp index bd5865a2f9e4..62743de1871d 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_inner.test.cpp @@ -2,6 +2,7 @@ #include "testing_harness.hpp" #include "aztec3/circuits/abis/membership_witness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/apps/test_apps/escrow/deposit.hpp" #include "aztec3/circuits/kernel/private/common.hpp" #include "aztec3/constants.hpp" @@ -50,7 +51,7 @@ TEST_F(native_private_kernel_inner_tests, private_function_zero_storage_contract private_inputs.private_call.call_stack_item.contract_address = 0; // Modify the call stack item's hash with the newly added contract address. - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); // Invoke the native private kernel circuit @@ -76,7 +77,7 @@ TEST_F(native_private_kernel_inner_tests, private_function_incorrect_is_internal // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the function_data and public_inputs->call_context of the current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); // Invoke the native private kernel circuit @@ -195,7 +196,7 @@ TEST_F(native_private_kernel_inner_tests, DISABLED_private_function_incorrect_ca auto private_inputs = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); // Set the first call stack member corresponding to the `deposit` function to random scalar. - private_inputs.private_call.call_stack_item.public_inputs.private_call_stack[0] = NT::fr::random_element(); + private_inputs.private_call.call_stack_item.public_inputs.private_call_stack[0].value = NT::fr::random_element(); // Invoke the native private kernel circuit DummyBuilder builder = DummyBuilder("private_kernel_tests__private_function_incorrect_call_stack_item_hash_fails"); @@ -218,9 +219,9 @@ TEST_F(native_private_kernel_inner_tests, private_kernel_should_fail_if_aggregat do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); // Mock the previous new commitments to be full, therefore no need commitments can be added - std::array full_new_commitments{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> full_new_commitments{}; for (size_t i = 0; i < MAX_NEW_COMMITMENTS_PER_TX; ++i) { - full_new_commitments[i] = i + 1; + full_new_commitments[i].value = i + 1; } private_inputs.previous_kernel.public_inputs.end.new_commitments = full_new_commitments; native_private_kernel_circuit_inner(builder, private_inputs); @@ -252,7 +253,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_request) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -262,7 +263,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_request) private_inputs.private_call.call_stack_item.public_inputs.historic_block_data.private_data_tree_root = root; // tweak read_request so it gives wrong root when paired with its sibling path - read_requests[1] += 1; + read_requests[1].value += 1; private_inputs.private_call.call_stack_item.public_inputs.read_requests = read_requests; private_inputs.private_call.read_request_membership_witnesses = read_request_membership_witnesses; @@ -270,7 +271,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_request) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_read_request_bad_request"); @@ -291,7 +292,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_leaf_index) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -308,7 +309,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_leaf_index) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_read_request_bad_leaf_index"); @@ -329,7 +330,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_sibling_path) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -346,7 +347,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_bad_sibling_path) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_read_request_bad_sibling_path"); @@ -368,7 +369,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_root_mismatch) // generate two random sets of read requests and mix them so their roots don't match auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests0, read_request_membership_witnesses0, _transient_read_requests0, @@ -381,7 +382,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_root_mismatch) _transient_read_requests1, _transient_read_request_membership_witnesses1, _root] = get_random_reads(first_nullifier, contract_address, 2); - std::array bad_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> bad_requests{}; std::array, MAX_READ_REQUESTS_PER_CALL> bad_witnesses; // note we are using read_requests0 for some and read_requests1 for others bad_requests[0] = read_requests0[0]; @@ -398,7 +399,7 @@ TEST_F(native_private_kernel_inner_tests, native_read_request_root_mismatch) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_read_request_root_mismatch"); @@ -418,7 +419,7 @@ TEST_F(native_private_kernel_inner_tests, native_no_read_requests_works) auto private_inputs = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); // empty requests - std::array const read_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> const read_requests{}; std::array, MAX_READ_REQUESTS_PER_CALL> const read_request_membership_witnesses{}; private_inputs.private_call.call_stack_item.public_inputs.read_requests = read_requests; @@ -426,7 +427,7 @@ TEST_F(native_private_kernel_inner_tests, native_no_read_requests_works) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests of the current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_no_read_requests_works"); @@ -454,7 +455,7 @@ TEST_F(native_private_kernel_inner_tests, native_one_read_requests_works) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -467,7 +468,7 @@ TEST_F(native_private_kernel_inner_tests, native_one_read_requests_works) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests of the current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_one_read_requests_works"); @@ -495,7 +496,7 @@ TEST_F(native_private_kernel_inner_tests, native_two_read_requests_works) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -508,7 +509,7 @@ TEST_F(native_private_kernel_inner_tests, native_two_read_requests_works) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests of the current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_two_read_requests_works"); @@ -536,7 +537,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_works) private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, _transient_read_requests, @@ -550,7 +551,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_works) // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_max_read_requests_works"); @@ -578,7 +579,7 @@ TEST_F(native_private_kernel_inner_tests, native_one_transient_read_requests_wor private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, transient_read_requests, @@ -595,7 +596,7 @@ TEST_F(native_private_kernel_inner_tests, native_one_transient_read_requests_wor // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = DummyBuilder("native_private_kernel_inner_tests__native_one_transient_read_requests_works"); @@ -622,7 +623,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_one_transient private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, transient_read_requests, @@ -640,7 +641,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_one_transient // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = @@ -669,7 +670,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_all_transient private_inputs.private_call.call_stack_item.public_inputs.call_context.storage_contract_address; auto const first_nullifier = - silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]); + silo_nullifier(contract_address, private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value); auto [read_requests, read_request_membership_witnesses, transient_read_requests, @@ -683,7 +684,7 @@ TEST_F(native_private_kernel_inner_tests, native_max_read_requests_all_transient // We need to update the previous_kernel's private_call_stack because the current_call_stack_item has changed // i.e. we changed the public_inputs->read_requests and public_inputs->historic_private_data_tree_root of the // current_call_stack_item - private_inputs.previous_kernel.public_inputs.end.private_call_stack[0] = + private_inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = private_inputs.private_call.call_stack_item.hash(); DummyBuilder builder = diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp index c1fd7362e455..ee49da391782 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp @@ -4,6 +4,7 @@ #include "aztec3/circuits/abis/kernel_circuit_public_inputs_final.hpp" #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_kernel_inputs_ordering.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/constants.hpp" #include "aztec3/utils/array.hpp" @@ -17,6 +18,8 @@ using NT = aztec3::utils::types::NativeTypes; using aztec3::circuits::abis::KernelCircuitPublicInputsFinal; using aztec3::circuits::abis::PreviousKernelData; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; using aztec3::circuits::abis::private_kernel::PrivateKernelInputsOrdering; using aztec3::circuits::kernel::private_kernel::common_initialise_end_values; using aztec3::utils::array_rearrange; @@ -35,9 +38,9 @@ void initialise_end_values(PreviousKernelData const& previous_kernel, namespace aztec3::circuits::kernel::private_kernel { void match_reads_to_commitments(DummyCircuitBuilder& builder, - std::array const& read_requests, + std::array, MAX_READ_REQUESTS_PER_TX> const& read_requests, std::array const& read_commitment_hints, - std::array const& new_commitments) + std::array, MAX_NEW_COMMITMENTS_PER_TX> const& new_commitments) { // match reads to commitments from the previous call(s) for (size_t rr_idx = 0; rr_idx < MAX_READ_REQUESTS_PER_TX; rr_idx++) { @@ -45,10 +48,10 @@ void match_reads_to_commitments(DummyCircuitBuilder& builder, const auto& read_commitment_hint = read_commitment_hints[rr_idx]; const auto hint_pos = static_cast(uint64_t(read_commitment_hint)); - if (read_request != 0) { + if (read_request.value != 0) { size_t match_pos = MAX_NEW_COMMITMENTS_PER_TX; if (hint_pos < MAX_NEW_COMMITMENTS_PER_TX) { - match_pos = read_request == new_commitments[hint_pos] ? hint_pos : match_pos; + match_pos = read_request.value == new_commitments[hint_pos].value ? hint_pos : match_pos; } builder.do_assert( @@ -57,7 +60,7 @@ void match_reads_to_commitments(DummyCircuitBuilder& builder, rr_idx, "]* is transient but does not match any new commitment.", "\n\tread_request: ", - read_request, + read_request.value, "\n\thint_to_commitment: ", read_commitment_hint, "\n\t* the read_request position/index is not expected to match position in app-circuit " @@ -90,10 +93,10 @@ void match_reads_to_commitments(DummyCircuitBuilder& builder, */ void match_nullifiers_to_commitments_and_squash( DummyCircuitBuilder& builder, - std::array& new_nullifiers, + std::array, MAX_NEW_NULLIFIERS_PER_TX>& new_nullifiers, std::array const& nullified_commitments, std::array const& nullifier_commitment_hints, - std::array& new_commitments) + std::array, MAX_NEW_COMMITMENTS_PER_TX>& new_commitments) { // match nullifiers/nullified_commitments to commitments from the previous call(s) for (size_t n_idx = 0; n_idx < MAX_NEW_NULLIFIERS_PER_TX; n_idx++) { @@ -117,12 +120,13 @@ void match_nullifiers_to_commitments_and_squash( // squash both the nullifier and the commitment // (set to 0 here and then rearrange array after loop) important("chopped commitment for siloed inner hash note \n", new_commitments[match_pos]); - new_commitments[match_pos] = NT::fr(0); - new_nullifiers[n_idx] = NT::fr(0); + new_commitments[match_pos] = SideEffect{ .value = 0, .side_effect_counter = 0 }; + new_nullifiers[n_idx] = + SideEffectLinkedToNoteHash{ .value = 0, .note_hash = 0, .side_effect_counter = 0 }; } else { // Transient nullifiers MUST match a pending commitment builder.do_assert(false, - format("new_nullifier at position [", + format("OLD new_nullifier at position [", n_idx, "]* is transient but does not match any new commitment.", "\n\tnullifier: ", @@ -132,6 +136,35 @@ void match_nullifiers_to_commitments_and_squash( CircuitErrorCode::PRIVATE_KERNEL__TRANSIENT_NEW_NULLIFIER_NO_MATCH); } } + const auto& nullifier = new_nullifiers[n_idx]; + if (nullifier.note_hash != NT::fr(0) && nullifier.note_hash != NT::fr(EMPTY_NULLIFIED_COMMITMENT)) { + size_t match_pos = MAX_NEW_COMMITMENTS_PER_TX; + // TODO(https://github.com/AztecProtocol/aztec-packages/issues/837): inefficient + // O(n^2) inner loop will be optimized via matching hints + for (size_t c_idx = 0; c_idx < MAX_NEW_COMMITMENTS_PER_TX; c_idx++) { + // If there are multiple matches, this picks the last one + match_pos = (nullifier.note_hash == new_commitments[c_idx].value) ? c_idx : match_pos; + } + + if (match_pos != MAX_NEW_COMMITMENTS_PER_TX) { + // match found! + // squash both the nullifier and the commitment + // (set to 0 here and then rearrange array after loop) + new_commitments[match_pos] = {}; + new_nullifiers[n_idx] = {}; + } else { + // Transient nullifiers MUST match a pending commitment + builder.do_assert(false, + format("new_nullifier at position [", + n_idx, + "]* is transient but does not match any new commitment.", + "\n\tnullifier: ", + nullifier.value, + "\n\tnullified_commitment: ", + nullifier.note_hash), + CircuitErrorCode::PRIVATE_KERNEL__TRANSIENT_NEW_NULLIFIER_NO_MATCH); + } + } // non-transient (persistable) nullifiers are just kept in new_nullifiers array and forwarded // to public inputs (used later by base rollup circuit) } @@ -141,14 +174,14 @@ void match_nullifiers_to_commitments_and_squash( } void apply_commitment_nonces(NT::fr const& first_nullifier, - std::array& new_commitments) + std::array, MAX_NEW_COMMITMENTS_PER_TX>& new_commitments) { for (size_t c_idx = 0; c_idx < MAX_NEW_COMMITMENTS_PER_TX; c_idx++) { // Apply nonce to all non-zero/non-empty commitments // Nonce is the hash of the first (0th) nullifier and the commitment's index into new_commitments array const auto nonce = compute_commitment_nonce(first_nullifier, c_idx); - new_commitments[c_idx] = - new_commitments[c_idx] == 0 ? 0 : compute_unique_commitment(nonce, new_commitments[c_idx]); + new_commitments[c_idx].value = + new_commitments[c_idx].value == 0 ? 0 : compute_unique_commitment(nonce, new_commitments[c_idx].value); } } @@ -186,7 +219,7 @@ KernelCircuitPublicInputsFinal native_private_kernel_circuit_ordering( public_inputs.end.new_commitments); // tx hash - const auto& first_nullifier = private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0]; + const auto& first_nullifier = private_inputs.previous_kernel.public_inputs.end.new_nullifiers[0].value; apply_commitment_nonces(first_nullifier, public_inputs.end.new_commitments); return public_inputs; diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.test.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.test.cpp index 829366423c8e..8a6422bc4460 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.test.cpp @@ -1,5 +1,6 @@ #include "testing_harness.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/apps/test_apps/escrow/deposit.hpp" #include "aztec3/circuits/kernel/private/common.hpp" #include "aztec3/constants.hpp" @@ -18,6 +19,9 @@ namespace aztec3::circuits::kernel::private_kernel { using aztec3::circuits::apps::test_apps::escrow::deposit; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; +using aztec3::circuits::abis::SideEffectWithRange; using aztec3::circuits::kernel::private_kernel::testing_harness::do_private_call_get_kernel_inputs_inner; using aztec3::utils::array_length; using aztec3::utils::CircuitErrorCode; @@ -81,23 +85,23 @@ TEST_F(native_private_kernel_ordering_tests, native_matching_one_read_request_to { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_nullifiers{}; - std::array siloed_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> siloed_commitments{}; std::array unique_siloed_commitments{}; - std::array read_requests{}; + std::array, MAX_READ_REQUESTS_PER_TX> read_requests{}; std::array hints{}; std::array, MAX_READ_REQUESTS_PER_TX> read_request_membership_witnesses{}; - new_nullifiers[0] = NT::fr::random_element(); - siloed_commitments[0] = NT::fr::random_element(); // create random commitment + new_nullifiers[0].value = NT::fr::random_element(); + siloed_commitments[0].value = NT::fr::random_element(); // create random commitment // ordering circuit applies nonces to commitments - const auto nonce = compute_commitment_nonce(new_nullifiers[0], 0); + const auto nonce = compute_commitment_nonce(new_nullifiers[0].value, 0); unique_siloed_commitments[0] = - siloed_commitments[0] == 0 ? 0 : compute_unique_commitment(nonce, siloed_commitments[0]); + siloed_commitments[0].value == 0 ? 0 : compute_unique_commitment(nonce, siloed_commitments[0].value); - read_requests[0] = siloed_commitments[0]; + read_requests[0].value = siloed_commitments[0].value; // hints[0] == fr(0) due to the default initialization of hints read_request_membership_witnesses[0].is_transient = true; @@ -115,32 +119,33 @@ TEST_F(native_private_kernel_ordering_tests, native_matching_one_read_request_to ASSERT_FALSE(builder.failed()) << "failure: " << builder.get_first_failure(); ASSERT_TRUE(array_length(public_inputs.end.new_commitments) == 1); - ASSERT_TRUE(public_inputs.end.new_commitments[0] == unique_siloed_commitments[0]); + ASSERT_TRUE(public_inputs.end.new_commitments[0].value == unique_siloed_commitments[0]); } TEST_F(native_private_kernel_ordering_tests, native_matching_some_read_requests_to_commitments_works) { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_nullifiers{}; - std::array siloed_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> siloed_commitments{}; std::array unique_siloed_commitments{}; - std::array read_requests{}; + std::array, MAX_READ_REQUESTS_PER_TX> read_requests{}; std::array hints{}; std::array, MAX_READ_REQUESTS_PER_TX> read_request_membership_witnesses{}; - new_nullifiers[0] = NT::fr::random_element(); - const auto& first_nullifier = new_nullifiers[0]; + new_nullifiers[0].value = NT::fr::random_element(); + const auto& first_nullifier = new_nullifiers[0].value; // create random commitments to input to ordering circuit, and compute their "unique" versions // to be expected at the output for (size_t c_idx = 0; c_idx < MAX_NEW_COMMITMENTS_PER_TX; c_idx++) { - siloed_commitments[c_idx] = NT::fr::random_element(); // create random commitment + siloed_commitments[c_idx].value = NT::fr::random_element(); // create random commitment // ordering circuit applies nonces to commitments const auto nonce = compute_commitment_nonce(first_nullifier, c_idx); - unique_siloed_commitments[c_idx] = - siloed_commitments[c_idx] == 0 ? 0 : compute_unique_commitment(nonce, siloed_commitments[c_idx]); + unique_siloed_commitments[c_idx] = siloed_commitments[c_idx].value == 0 + ? 0 + : compute_unique_commitment(nonce, siloed_commitments[c_idx].value); } read_requests[0] = siloed_commitments[1]; @@ -166,7 +171,7 @@ TEST_F(native_private_kernel_ordering_tests, native_matching_some_read_requests_ ASSERT_TRUE(array_length(public_inputs.end.new_commitments) == MAX_NEW_COMMITMENTS_PER_TX); // ensure that commitments had nonce applied properly and all appear at output for (size_t c_idx = 0; c_idx < MAX_NEW_COMMITMENTS_PER_TX; c_idx++) { - ASSERT_TRUE(public_inputs.end.new_commitments[c_idx] == unique_siloed_commitments[c_idx]); + ASSERT_TRUE(public_inputs.end.new_commitments[c_idx].value == unique_siloed_commitments[c_idx]); } } @@ -174,19 +179,19 @@ TEST_F(native_private_kernel_ordering_tests, native_read_request_unknown_fails) { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array siloed_commitments{}; - std::array read_requests{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> siloed_commitments{}; + std::array, MAX_READ_REQUESTS_PER_TX> read_requests{}; std::array hints{}; std::array, MAX_READ_REQUESTS_PER_TX> read_request_membership_witnesses{}; for (size_t c_idx = 0; c_idx < MAX_NEW_COMMITMENTS_PER_TX; c_idx++) { - siloed_commitments[c_idx] = NT::fr::random_element(); // create random commitment + siloed_commitments[c_idx].value = NT::fr::random_element(); // create random commitment read_requests[c_idx] = siloed_commitments[c_idx]; // create random read requests hints[c_idx] = fr(c_idx); // ^ will match each other! read_request_membership_witnesses[c_idx].is_transient = true; // ordering circuit only allows transient reads } - read_requests[3] = NT::fr::random_element(); // force one read request not to match + read_requests[3].value = NT::fr::random_element(); // force one read request not to match auto& previous_kernel = private_inputs_inner.previous_kernel; @@ -206,14 +211,14 @@ TEST_F(native_private_kernel_ordering_tests, native_squash_one_of_one_transient_ { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; std::array nullifier_commitments{}; const auto commitment0 = fr(213); - new_commitments[0] = commitment0; + new_commitments[0].value = commitment0; - new_nullifiers[0] = fr(32); + new_nullifiers[0].value = fr(32); nullifier_commitments[0] = commitment0; auto& previous_kernel = private_inputs_inner.previous_kernel; @@ -239,15 +244,15 @@ TEST_F(native_private_kernel_ordering_tests, native_squash_one_of_two_transient_ { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; std::array nullifier_commitments{}; const auto commitment1 = fr(213); - new_commitments[0] = fr(763); - new_commitments[1] = commitment1; + new_commitments[0].value = fr(763); + new_commitments[1].value = commitment1; - new_nullifiers[0] = fr(32); + new_nullifiers[0].value = fr(32); nullifier_commitments[0] = commitment1; auto& previous_kernel = private_inputs_inner.previous_kernel; @@ -273,17 +278,17 @@ TEST_F(native_private_kernel_ordering_tests, native_squash_two_of_two_transient_ { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; std::array nullifier_commitments{}; const auto commitment0 = fr(763); const auto commitment1 = fr(213); - new_commitments[0] = commitment0; - new_commitments[1] = commitment1; + new_commitments[0].value = commitment0; + new_commitments[1].value = commitment1; - new_nullifiers[0] = fr(32); - new_nullifiers[1] = fr(43); + new_nullifiers[0].value = fr(32); + new_nullifiers[1].value = fr(43); nullifier_commitments[0] = commitment1; nullifier_commitments[1] = commitment0; @@ -310,13 +315,13 @@ TEST_F(native_private_kernel_ordering_tests, native_empty_nullified_commitment_m { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; std::array nullifier_commitments{}; - new_commitments[0] = fr(213); + new_commitments[0].value = fr(213); - new_nullifiers[0] = fr(32); + new_nullifiers[0].value = fr(32); nullifier_commitments[0] = fr(EMPTY_NULLIFIED_COMMITMENT); auto& previous_kernel = private_inputs_inner.previous_kernel; @@ -342,11 +347,11 @@ TEST_F(native_private_kernel_ordering_tests, native_empty_nullified_commitment_m { auto private_inputs_inner = do_private_call_get_kernel_inputs_inner(false, deposit, standard_test_args()); - std::array new_commitments{}; - std::array new_nullifiers{}; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers{}; std::array nullifier_commitments{}; - new_nullifiers[0] = fr(32); + new_nullifiers[0].value = fr(32); nullifier_commitments[0] = fr(EMPTY_NULLIFIED_COMMITMENT); auto& previous_kernel = private_inputs_inner.previous_kernel; diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/private_kernel_circuit.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/private_kernel_circuit.cpp index 77a6f9549a6a..6371611f52af 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/private_kernel_circuit.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/private_kernel_circuit.cpp @@ -3,8 +3,10 @@ #include "aztec3/circuits/abis/kernel_circuit_public_inputs.hpp" #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/private_kernel/private_kernel_inputs_inner.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/constants.hpp" +#include "aztec3/utils/array.hpp" #include @@ -12,6 +14,9 @@ namespace aztec3::circuits::kernel::private_kernel { using aztec3::circuits::abis::KernelCircuitPublicInputs; using aztec3::circuits::abis::NewContractData; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; +using aztec3::circuits::abis::SideEffectWithRange; using aztec3::circuits::abis::private_kernel::PrivateKernelInputsInner; using plonk::stdlib::array_length; @@ -20,6 +25,12 @@ using plonk::stdlib::array_push; using plonk::stdlib::is_array_empty; using plonk::stdlib::push_array_to_array; +using aztec3::utils::aztec_circuit_array_length; +using aztec3::utils::aztec_circuit_array_pop; +using aztec3::utils::aztec_circuit_array_push; +using aztec3::utils::aztec_circuit_is_array_empty; +using aztec3::utils::aztec_circuit_push_array_to_array; + using aztec3::circuits::compute_constructor_hash; using aztec3::circuits::compute_contract_address; using aztec3::circuits::silo_commitment; @@ -92,8 +103,8 @@ void update_end_values(PrivateKernelInputsInner const& private_inputs, Kerne const auto& is_static_call = private_call_public_inputs.call_context.is_static_call; // No state changes are allowed for static calls: - is_static_call.must_imply(is_array_empty(new_commitments) == true); - is_static_call.must_imply(is_array_empty(new_nullifiers) == true); + is_static_call.must_imply(aztec_circuit_is_array_empty(new_commitments) == true); + is_static_call.must_imply(aztec_circuit_is_array_empty(new_nullifiers) == true); // TODO: name change (just contract_address) const auto& storage_contract_address = private_call_public_inputs.call_context.storage_contract_address; @@ -135,7 +146,9 @@ void update_end_values(PrivateKernelInputsInner const& private_inputs, Kerne // push the contract address nullifier to nullifier vector CT::fr const conditional_contract_address_nullifier = CT::fr::conditional_assign(is_contract_deployment, contract_address_nullifier, CT::fr(0)); - array_push(public_inputs.end.new_nullifiers, conditional_contract_address_nullifier); + aztec_circuit_array_push( + public_inputs.end.new_nullifiers, + { conditional_contract_address_nullifier, fr(EMPTY_NULLIFIED_COMMITMENT), 0 }); // Add new contract data if its a contract deployment function auto const new_contract_data = NewContractData{ @@ -144,31 +157,46 @@ void update_end_values(PrivateKernelInputsInner const& private_inputs, Kerne .function_tree_root = contract_deployment_data.function_tree_root, }; - array_push, MAX_NEW_CONTRACTS_PER_TX>(public_inputs.end.new_contracts, - new_contract_data); + aztec_circuit_array_push, MAX_NEW_CONTRACTS_PER_TX>( + public_inputs.end.new_contracts, new_contract_data); } { // commitments, nullifiers, and contracts - std::array siloed_new_commitments; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> siloed_new_commitments; for (size_t i = 0; i < new_commitments.size(); ++i) { - siloed_new_commitments[i] = CT::fr::conditional_assign( - new_commitments[i] == 0, 0, silo_commitment(storage_contract_address, new_commitments[i])); + const auto& commitment = new_commitments[i]; + // TODO(dbanks12): check value == 0 or is_empty here? Think about security implications either way + // instinct is that value == 0 is actually safer? + siloed_new_commitments[i] = + SideEffect::conditional_assign(commitment.value == 0, + {}, + SideEffect{ + silo_commitment(storage_contract_address, commitment.value), + commitment.side_effect_counter, + }); } - std::array siloed_new_nullifiers; + std::array, MAX_NEW_NULLIFIERS_PER_CALL> siloed_new_nullifiers; for (size_t i = 0; i < new_nullifiers.size(); ++i) { - siloed_new_nullifiers[i] = CT::fr::conditional_assign( - new_nullifiers[i] == 0, 0, silo_nullifier(storage_contract_address, new_nullifiers[i])); + const auto& nullifier = new_nullifiers[i]; + siloed_new_nullifiers[i] = SideEffectLinkedToNoteHash::conditional_assign( + nullifier.value == 0, + {}, + SideEffectLinkedToNoteHash{ + silo_nullifier(storage_contract_address, nullifier.value), + nullifier.note_hash, + nullifier.side_effect_counter, + }); } // Add new commitments/etc to AggregatedData - push_array_to_array(siloed_new_commitments, public_inputs.end.new_commitments); - push_array_to_array(siloed_new_nullifiers, public_inputs.end.new_nullifiers); + aztec_circuit_push_array_to_array(siloed_new_commitments, public_inputs.end.new_commitments); + aztec_circuit_push_array_to_array(siloed_new_nullifiers, public_inputs.end.new_nullifiers); } { // call stacks // copy the private function circuit's callstack into the AggregatedData const auto& this_private_call_stack = private_call_public_inputs.private_call_stack; - push_array_to_array(this_private_call_stack, public_inputs.end.private_call_stack); + aztec_circuit_push_array_to_array(this_private_call_stack, public_inputs.end.private_call_stack); } // { @@ -193,7 +221,7 @@ void validate_this_private_call_hash(PrivateKernelInputsInner const& private const auto& start = private_inputs.previous_kernel.public_inputs.end; // TODO: this logic might need to change to accommodate the weird edge 3 initial txs (the 'main' tx, the 'fee' tx, // and the 'gas rebate' tx). - const auto this_private_call_hash = array_pop(start.private_call_stack); + const auto this_private_call_hash = aztec_circuit_array_pop(start.private_call_stack).value; const auto calculated_this_private_call_hash = private_inputs.private_call.call_stack_item.hash(); this_private_call_hash.assert_equal(calculated_this_private_call_hash, "this private_call_hash does not reconcile"); @@ -212,7 +240,7 @@ void validate_this_private_call_stack(PrivateKernelInputsInner const& privat const auto& stack = private_inputs.private_call.call_stack_item.public_inputs.private_call_stack; const auto& preimages = private_inputs.private_call.private_call_stack_preimages; for (size_t i = 0; i < stack.size(); ++i) { - const auto& hash = stack[i]; + const auto& hash = stack[i].value; const auto& preimage = preimages[i]; // Note: this assumes it's computationally infeasible to have `0` as a valid call_stack_item_hash. @@ -243,9 +271,9 @@ void validate_inputs(PrivateKernelInputsInner const& private_inputs, bool fi // These lengths are calculated by counting entries until a non-zero one is encountered // True array length is constant which is a property we need for circuit inputs, // but we want to know "length" in terms of how many nonzero entries have been inserted - CT::fr const start_private_call_stack_length = array_length(start.private_call_stack); - CT::fr const start_public_call_stack_length = array_length(start.public_call_stack); - CT::fr const start_new_l2_to_l1_msgs_length = array_length(start.new_l2_to_l1_msgs); + CT::fr const start_private_call_stack_length = aztec_circuit_array_length(start.private_call_stack); + CT::fr const start_public_call_stack_length = aztec_circuit_array_length(start.public_call_stack); + CT::fr const start_new_l2_to_l1_msgs_length = aztec_circuit_array_length(start.new_l2_to_l1_msgs); // Recall: we can't do traditional `if` statements in a circuit; all code paths are always executed. The below is // some syntactic sugar, which seeks readability similar to an `if` statement. diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.cpp index fb3f08202ab1..1e95adee8f53 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.cpp @@ -12,6 +12,7 @@ #include "aztec3/circuits/abis/historic_block_data.hpp" #include "aztec3/circuits/abis/private_circuit_public_inputs.hpp" #include "aztec3/circuits/abis/private_kernel/private_call_data.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/abis/tx_context.hpp" #include "aztec3/circuits/abis/tx_request.hpp" #include "aztec3/circuits/abis/types.hpp" @@ -53,15 +54,15 @@ using aztec3::utils::array_length; * @param num_read_requests if negative, use random num. Must be < MAX_READ_REQUESTS_PER_CALL * @return std::tuple */ -std::tuple, +std::tuple, MAX_READ_REQUESTS_PER_CALL>, std::array, MAX_READ_REQUESTS_PER_CALL>, - std::array, + std::array, MAX_READ_REQUESTS_PER_CALL>, std::array, MAX_READ_REQUESTS_PER_CALL>, NT::fr> get_random_reads(NT::fr const& first_nullifier, NT::fr const& contract_address, int const num_read_requests) { - std::array transient_read_requests{}; - std::array read_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> transient_read_requests{}; + std::array, MAX_READ_REQUESTS_PER_CALL> read_requests{}; std::array leaves{}; // randomize the number of read requests with a configurable minimum @@ -72,15 +73,15 @@ get_random_reads(NT::fr const& first_nullifier, NT::fr const& contract_address, for (size_t rr = 0; rr < final_num_rr; rr++) { // randomize commitment and its leaf index // transient read requests are raw (not siloed and not unique at input to kernel circuit) - transient_read_requests[rr] = NT::fr::random_element(); + transient_read_requests[rr].value = NT::fr::random_element(); - const auto siloed_commitment = silo_commitment(contract_address, read_requests[rr]); + const auto siloed_commitment = silo_commitment(contract_address, read_requests[rr].value); const auto nonce = compute_commitment_nonce(first_nullifier, rr); const auto unique_siloed_commitment = siloed_commitment == 0 ? 0 : compute_unique_commitment(nonce, siloed_commitment); leaves[rr] = unique_siloed_commitment; - read_requests[rr] = unique_siloed_commitment; + read_requests[rr].value = unique_siloed_commitment; } // this set and the following loop lets us generate totally random leaf indices @@ -290,8 +291,8 @@ std::pair, ContractDeploymentData> create_private_call_d .call_context = call_context, .args_hash = args_hash, .return_values = {}, - .new_commitments = { NT::fr::random_element() }, // One random commitment - .new_nullifiers = { NT::fr::random_element() }, // One random nullifier + .new_commitments = { { { NT::fr::random_element() } } }, // One random commitment + .new_nullifiers = { { { NT::fr::random_element() } } }, // One random nullifier .nullified_commitments = {}, .private_call_stack = {}, .new_l2_to_l1_msgs = {}, @@ -474,8 +475,8 @@ PrivateKernelInputsInner do_private_call_get_kernel_inputs_inner( // We mock a kernel circuit proof to initialize ipnut required by an inner call //*************************************************************************** - std::array initial_kernel_private_call_stack{}; - initial_kernel_private_call_stack[0] = private_call_data.call_stack_item.hash(); + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX> initial_kernel_private_call_stack{}; + initial_kernel_private_call_stack[0].value = private_call_data.call_stack_item.hash(); auto const& private_circuit_public_inputs = private_call_data.call_stack_item.public_inputs; // Get dummy previous kernel diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.hpp b/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.hpp index 37618d7571b1..4aa35ea5c33b 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.hpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/testing_harness.hpp @@ -91,9 +91,9 @@ inline const auto& get_empty_contract_siblings() * transient_read_request_memberships_witnesses, * historic_private_data_tree_root> */ -std::tuple, +std::tuple, MAX_READ_REQUESTS_PER_CALL>, std::array, MAX_READ_REQUESTS_PER_CALL>, - std::array, + std::array, MAX_READ_REQUESTS_PER_CALL>, std::array, MAX_READ_REQUESTS_PER_CALL>, NT::fr> get_random_reads(NT::fr const& first_nullifier, NT::fr const& contract_address, int num_read_requests); diff --git a/circuits/cpp/src/aztec3/circuits/kernel/public/.test.cpp b/circuits/cpp/src/aztec3/circuits/kernel/public/.test.cpp index 8f89b495ed20..027a494cd693 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/public/.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/public/.test.cpp @@ -10,6 +10,7 @@ #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/public_kernel/public_call_data.hpp" #include "aztec3/circuits/abis/public_kernel/public_kernel_inputs.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/abis/tx_context.hpp" #include "aztec3/circuits/abis/tx_request.hpp" #include "aztec3/circuits/abis/types.hpp" @@ -21,6 +22,7 @@ #include #include +#include namespace aztec3::circuits::kernel::public_kernel { using DummyCircuitBuilder = aztec3::utils::DummyCircuitBuilder; @@ -56,6 +58,17 @@ std::array array_of_values(NT::uint32& count, NT::uint32 num_value return values; } +template +std::array array_of_sideeffect_values(NT::uint32& count, NT::uint32 num_values_required = SIZE) +{ + ASSERT(num_values_required <= SIZE); + std::array values{}; + for (size_t i = 0; i < num_values_required; i++) { + values[i].value = ++count; + } + return values; +} + template std::array empty_array_of_values() { std::array values{}; @@ -118,14 +131,14 @@ PublicCallStackItem generate_call_stack_item(NT::fr contract_address, }; fr const args_hash = count; std::array const return_values = array_of_values(count); - std::array const public_call_stack = - array_of_values(count); - std::array const new_commitments = - array_of_values(count); - std::array const new_nullifiers = - array_of_values(count); - std::array const new_l2_to_l1_msgs = - array_of_values(count); + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> const public_call_stack = + array_of_sideeffect_values>(count); + std::array, MAX_NEW_COMMITMENTS_PER_CALL> const new_commitments = + array_of_sideeffect_values>(count); + std::array, MAX_NEW_NULLIFIERS_PER_CALL> const new_nullifiers = + array_of_sideeffect_values>(count); + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> const new_l2_to_l1_msgs = + array_of_sideeffect_values>(count); std::array, MAX_PUBLIC_DATA_READS_PER_CALL> const reads = generate_contract_storage_reads(count); std::array, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL> const update_requests = @@ -203,42 +216,47 @@ public_data_update_requests_from_contract_storage_update_requests( return values; } -std::array new_commitments_as_siloed_commitments( - std::array const& new_commitments, NT::fr const& contract_address) +std::array, MAX_NEW_COMMITMENTS_PER_CALL> new_commitments_as_siloed_commitments( + std::array, MAX_NEW_COMMITMENTS_PER_CALL> const& new_commitments, NT::fr const& contract_address) { - std::array siloed_commitments{}; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> siloed_commitments{}; for (size_t i = 0; i < MAX_NEW_COMMITMENTS_PER_CALL; ++i) { - if (!new_commitments[i].is_zero()) { - siloed_commitments[i] = silo_commitment(contract_address, new_commitments[i]); + if (!new_commitments[i].is_empty()) { + siloed_commitments[i].value = silo_commitment(contract_address, new_commitments[i].value); + siloed_commitments[i].side_effect_counter = new_commitments[i].side_effect_counter; } } return siloed_commitments; } -std::array new_nullifiers_as_siloed_nullifiers( - std::array const& new_nullifiers, NT::fr const& contract_address) +std::array, MAX_NEW_NULLIFIERS_PER_CALL> new_nullifiers_as_siloed_nullifiers( + std::array, MAX_NEW_NULLIFIERS_PER_CALL> const& new_nullifiers, + NT::fr const& contract_address) { - std::array siloed_nullifiers{}; + std::array, MAX_NEW_NULLIFIERS_PER_CALL> siloed_nullifiers{}; for (size_t i = 0; i < MAX_NEW_NULLIFIERS_PER_CALL; ++i) { - if (!new_nullifiers[i].is_zero()) { - siloed_nullifiers[i] = silo_nullifier(contract_address, new_nullifiers[i]); + if (!new_nullifiers[i].is_empty()) { + siloed_nullifiers[i].value = silo_nullifier(contract_address, new_nullifiers[i].value); + siloed_nullifiers[i].note_hash = new_nullifiers[i].note_hash; + siloed_nullifiers[i].side_effect_counter = new_nullifiers[i].side_effect_counter; } } return siloed_nullifiers; } -std::array new_l2_messages_from_message( - std::array const& new_messages, +std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> new_l2_messages_from_message( + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> const& new_messages, NT::fr const& contract_address, fr const& portal_contract_address, fr const& chain_id, fr const& version) { - std::array formatted_msgs{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> formatted_msgs{}; for (size_t i = 0; i < MAX_NEW_L2_TO_L1_MSGS_PER_CALL; ++i) { - if (!new_messages[i].is_zero()) { - formatted_msgs[i] = compute_l2_to_l1_hash( - contract_address, version, portal_contract_address, chain_id, new_messages[i]); + if (!new_messages[i].is_empty()) { + formatted_msgs[i].value = compute_l2_to_l1_hash( + contract_address, version, portal_contract_address, chain_id, new_messages[i].value); + formatted_msgs[i].side_effect_counter = new_messages[i].side_effect_counter; } } return formatted_msgs; @@ -297,7 +315,7 @@ PublicKernelInputs get_kernel_inputs_with_previous_kernel(NT::boolean privat std::array child_call_stacks; NT::fr child_contract_address = 100000; NT::fr child_portal_contract_address = 200000; - std::array call_stack_hashes{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> call_stack_hashes{}; for (size_t i = 0; i < MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL; i++) { // NOLINTNEXTLINE(readability-suspicious-call-argument) child_call_stacks[i] = generate_call_stack_item(child_contract_address, @@ -306,7 +324,7 @@ PublicKernelInputs get_kernel_inputs_with_previous_kernel(NT::boolean privat child_portal_contract_address, false, seed); - call_stack_hashes[i] = child_call_stacks[i].hash(); + call_stack_hashes[i].value = child_call_stacks[i].hash(); child_contract_address++; child_portal_contract_address++; } @@ -317,12 +335,15 @@ PublicKernelInputs get_kernel_inputs_with_previous_kernel(NT::boolean privat generate_contract_storage_update_requests(seed, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL / 2); std::array, MAX_PUBLIC_DATA_READS_PER_CALL> const reads = generate_contract_storage_reads(seed, MAX_PUBLIC_DATA_READS_PER_CALL / 2); - std::array const new_commitments = - array_of_values(seed, MAX_NEW_COMMITMENTS_PER_CALL / 2); - std::array const new_nullifiers = - array_of_values(seed, MAX_NEW_NULLIFIERS_PER_CALL / 2); - std::array const new_l2_to_l1_msgs = - array_of_values(seed, MAX_NEW_L2_TO_L1_MSGS_PER_CALL / 2); + std::array, MAX_NEW_COMMITMENTS_PER_CALL> const new_commitments = + array_of_sideeffect_values>(seed, + MAX_NEW_COMMITMENTS_PER_CALL / 2); + std::array, MAX_NEW_NULLIFIERS_PER_CALL> const new_nullifiers = + array_of_sideeffect_values>( + seed, MAX_NEW_NULLIFIERS_PER_CALL / 2); + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> const new_l2_to_l1_msgs = + array_of_sideeffect_values>(seed, + MAX_NEW_L2_TO_L1_MSGS_PER_CALL / 2); std::array const unencrypted_logs_hash = array_of_values(seed, NUM_FIELDS_PER_SHA256); fr const unencrypted_log_preimages_length = ++seed; @@ -386,17 +407,18 @@ PublicKernelInputs get_kernel_inputs_with_previous_kernel(NT::boolean privat .contract_deployment_data = {}, } }; - std::array public_call_stack{}; - public_call_stack[0] = public_call_data.call_stack_item.hash(); + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX> public_call_stack{}; + public_call_stack[0].value = public_call_data.call_stack_item.hash(); CombinedAccumulatedData const end_accumulated_data = { - .new_commitments = - array_of_values(seed, private_previous ? MAX_NEW_COMMITMENTS_PER_TX / 2 : 0), - .new_nullifiers = - array_of_values(seed, private_previous ? MAX_NEW_NULLIFIERS_PER_TX / 2 : 0), - .private_call_stack = array_of_values(seed, 0), + .new_commitments = array_of_sideeffect_values>( + seed, private_previous ? MAX_NEW_COMMITMENTS_PER_TX / 2 : 0), + .new_nullifiers = array_of_sideeffect_values>( + seed, private_previous ? MAX_NEW_NULLIFIERS_PER_TX / 2 : 0), + .private_call_stack = + array_of_sideeffect_values>(seed, 0), .public_call_stack = public_call_stack, - .new_l2_to_l1_msgs = array_of_values( + .new_l2_to_l1_msgs = array_of_sideeffect_values>( seed, private_previous ? MAX_NEW_L2_TO_L1_MSGS_PER_TX / 2 : 0), .encrypted_logs_hash = array_of_values( seed, private_previous ? 2 : 0), // only private kernel is producing encrypted logs @@ -466,10 +488,11 @@ void validate_private_data_propagation(DummyBuilder& builder, const PublicKernelInputs& inputs, const KernelCircuitPublicInputs& public_inputs) { - ASSERT_TRUE(source_arrays_are_in_target(builder, - inputs.previous_kernel.public_inputs.end.private_call_stack, - std::array{}, - public_inputs.end.private_call_stack)); + ASSERT_TRUE( + source_arrays_are_in_target(builder, + inputs.previous_kernel.public_inputs.end.private_call_stack, + std::array, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX>{}, + public_inputs.end.private_call_stack)); ASSERT_TRUE(source_arrays_are_in_target(builder, inputs.previous_kernel.public_inputs.end.new_contracts, @@ -506,7 +529,7 @@ TEST(public_kernel_tests, only_valid_public_data_reads_should_be_propagated) inputs.public_call.call_stack_item.public_inputs.contract_storage_reads = reads; // adjust the call stack item hash for the current call in the previous iteration - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = inputs.public_call.call_stack_item.hash(); + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = inputs.public_call.call_stack_item.hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_EQ(dummyBuilder.get_first_failure(), utils::CircuitError::no_error()); @@ -551,7 +574,7 @@ TEST(public_kernel_tests, only_valid_update_requests_should_be_propagated) inputs.public_call.call_stack_item.public_inputs.contract_storage_update_requests = update_requests; // adjust the call stack item hash for the current call in the previous iteration - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = inputs.public_call.call_stack_item.hash(); + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = inputs.public_call.call_stack_item.hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_EQ(dummyBuilder.get_first_failure(), utils::CircuitError::no_error()); @@ -686,7 +709,7 @@ TEST(public_kernel_tests, incorrect_storage_contract_address_fails_for_regular_c inputs.public_call.public_call_stack_preimages[i].public_inputs.call_context.storage_contract_address = new_contract_address; // update the call stack item hash after the change in the preimage - inputs.public_call.call_stack_item.public_inputs.public_call_stack[i] = + inputs.public_call.call_stack_item.public_inputs.public_call_stack[i].value = inputs.public_call.public_call_stack_preimages[i].hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_TRUE(dummyBuilder.failed()); @@ -706,7 +729,7 @@ TEST(public_kernel_tests, incorrect_msg_sender_fails_for_regular_calls) // change the storage contract address so it does not equal the contract address inputs.public_call.public_call_stack_preimages[i].public_inputs.call_context.msg_sender = new_msg_sender; // update the call stack item hash after the change in the preimage - inputs.public_call.call_stack_item.public_inputs.public_call_stack[i] = + inputs.public_call.call_stack_item.public_inputs.public_call_stack[i].value = inputs.public_call.public_call_stack_preimages[i].hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_TRUE(dummyBuilder.failed()); @@ -739,7 +762,7 @@ TEST(public_kernel_tests, public_kernel_circuit_succeeds_for_mixture_of_regular_ is_delegate_call ? contract_portal_address : child_portal_contract_address, is_delegate_call, seed); - inputs.public_call.call_stack_item.public_inputs.public_call_stack[i] = + inputs.public_call.call_stack_item.public_inputs.public_call_stack[i].value = inputs.public_call.public_call_stack_preimages[i].hash(); // change the next call type @@ -750,7 +773,7 @@ TEST(public_kernel_tests, public_kernel_circuit_succeeds_for_mixture_of_regular_ // we update the hash of the current call stack item in the previous kernel, // since we modified the hash of the nested calls, which changes the hash of the parent item - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = inputs.public_call.call_stack_item.hash(); + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = inputs.public_call.call_stack_item.hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_EQ(dummyBuilder.get_first_failure(), utils::CircuitError::no_error()); @@ -771,7 +794,7 @@ TEST(public_kernel_tests, public_kernel_circuit_fails_on_incorrect_msg_sender_in std::array child_call_stacks; NT::uint32 const seed = 1000; NT::fr const child_contract_address = 100000; - std::array call_stack_hashes{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> call_stack_hashes{}; child_call_stacks[0] = // NOLINTNEXTLINE(readability-suspicious-call-argument) generate_call_stack_item(child_contract_address, @@ -780,7 +803,7 @@ TEST(public_kernel_tests, public_kernel_circuit_fails_on_incorrect_msg_sender_in contract_portal_address, true, seed); - call_stack_hashes[0] = child_call_stacks[0].hash(); + call_stack_hashes[0].value = child_call_stacks[0].hash(); inputs.public_call.call_stack_item.public_inputs.public_call_stack = call_stack_hashes; inputs.public_call.public_call_stack_preimages = child_call_stacks; @@ -804,14 +827,14 @@ TEST(public_kernel_tests, public_kernel_circuit_fails_on_incorrect_storage_contr std::array child_call_stacks; NT::uint32 const seed = 1000; NT::fr const child_contract_address = 100000; - std::array call_stack_hashes{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> call_stack_hashes{}; child_call_stacks[0] = generate_call_stack_item(child_contract_address, origin_msg_sender, child_contract_address, // this should be contract_address contract_portal_address, true, seed); - call_stack_hashes[0] = child_call_stacks[0].hash(); + call_stack_hashes[0].value = child_call_stacks[0].hash(); inputs.public_call.call_stack_item.public_inputs.public_call_stack = call_stack_hashes; inputs.public_call.public_call_stack_preimages = child_call_stacks; @@ -836,7 +859,7 @@ TEST(public_kernel_tests, public_kernel_circuit_fails_on_incorrect_portal_contra NT::uint32 const seed = 1000; NT::fr const child_contract_address = 100000; NT::fr const child_portal_contract = 200000; - std::array call_stack_hashes{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL> call_stack_hashes{}; // NOLINTNEXTLINE(readability-suspicious-call-argument) child_call_stacks[0] = generate_call_stack_item(child_contract_address, origin_msg_sender, @@ -844,7 +867,7 @@ TEST(public_kernel_tests, public_kernel_circuit_fails_on_incorrect_portal_contra child_portal_contract, // this should be contract_portal_address true, seed); - call_stack_hashes[0] = child_call_stacks[0].hash(); + call_stack_hashes[0].value = child_call_stacks[0].hash(); inputs.public_call.call_stack_item.public_inputs.public_call_stack = call_stack_hashes; inputs.public_call.public_call_stack_preimages = child_call_stacks; @@ -868,7 +891,7 @@ TEST(public_kernel_tests, public_kernel_circuit_only_checks_non_empty_call_stack // these call stack items will have an contract portal address but will be ignored as the call stack will be ignored std::array& child_call_stacks = inputs.public_call.public_call_stack_preimages; - std::array& call_stack_hashes = + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL>& call_stack_hashes = inputs.public_call.call_stack_item.public_inputs.public_call_stack; NT::uint32 const seed = 1000; NT::fr const child_contract_address = 100000; @@ -882,10 +905,10 @@ TEST(public_kernel_tests, public_kernel_circuit_only_checks_non_empty_call_stack false, seed); // setting this to zero makes the call stack item be ignored so it won't fail - call_stack_hashes[i] = 0; + call_stack_hashes[i].value = 0; } // adjust the call stack item hash for the current call in the previous iteration - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = inputs.public_call.call_stack_item.hash(); + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = inputs.public_call.call_stack_item.hash(); auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_EQ(dummyBuilder.get_first_failure(), utils::CircuitError::no_error()); @@ -920,7 +943,7 @@ TEST(public_kernel_tests, private_previous_kernel_non_empty_private_call_stack_s DummyBuilder dummyBuilder = DummyBuilder("public_kernel_tests__private_previous_kernel_non_empty_private_call_stack_should_fail"); PublicKernelInputs inputs = get_kernel_inputs_with_previous_kernel(true); - inputs.previous_kernel.public_inputs.end.private_call_stack[0] = 1; + inputs.previous_kernel.public_inputs.end.private_call_stack[0].value = 1; auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_TRUE(dummyBuilder.failed()); ASSERT_EQ(dummyBuilder.get_first_failure().code, CircuitErrorCode::PUBLIC_KERNEL__NON_EMPTY_PRIVATE_CALL_STACK); @@ -932,7 +955,7 @@ TEST(public_kernel_tests, private_previous_kernel_empty_public_call_stack_should DummyBuilder("public_kernel_tests__private_previous_kernel_empty_public_call_stack_should_fail"); PublicKernelInputs inputs = get_kernel_inputs_with_previous_kernel(true); inputs.previous_kernel.public_inputs.end.public_call_stack = - std::array{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX>{}; auto public_inputs = native_public_kernel_circuit_private_previous_kernel(dummyBuilder, inputs); ASSERT_TRUE(dummyBuilder.failed()); ASSERT_EQ(dummyBuilder.get_first_failure().code, CircuitErrorCode::PUBLIC_KERNEL__EMPTY_PUBLIC_CALL_STACK); @@ -996,7 +1019,7 @@ TEST(public_kernel_tests, public_previous_kernel_empty_public_call_stack_should_ DummyBuilder("public_kernel_tests__public_previous_kernel_empty_public_call_stack_should_fail"); PublicKernelInputs inputs = get_kernel_inputs_with_previous_kernel(false); inputs.previous_kernel.public_inputs.end.public_call_stack = - std::array{}; + std::array, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX>{}; auto public_inputs = native_public_kernel_circuit_public_previous_kernel(dummyBuilder, inputs); ASSERT_TRUE(dummyBuilder.failed()); ASSERT_EQ(dummyBuilder.get_first_failure().code, CircuitErrorCode::PUBLIC_KERNEL__EMPTY_PUBLIC_CALL_STACK); @@ -1052,20 +1075,20 @@ TEST(public_kernel_tests, circuit_outputs_should_be_correctly_populated_with_pre inputs.previous_kernel.public_inputs.end.public_data_reads = initial_reads; // setup 2 previous new commitments - std::array initial_commitments{}; - initial_commitments[0] = fr(1); - initial_commitments[1] = fr(2); + std::array, MAX_NEW_COMMITMENTS_PER_TX> initial_commitments{}; + initial_commitments[0].value = fr(1); + initial_commitments[1].value = fr(2); inputs.previous_kernel.public_inputs.end.new_commitments = initial_commitments; // setup 2 previous new nullifiers - std::array initial_nullifiers{}; - initial_nullifiers[0] = fr(12345); - initial_nullifiers[1] = fr(67890); + std::array, MAX_NEW_NULLIFIERS_PER_TX> initial_nullifiers{}; + initial_nullifiers[0].value = fr(12345); + initial_nullifiers[1].value = fr(67890); inputs.previous_kernel.public_inputs.end.new_nullifiers = initial_nullifiers; // setup 1 new l2 to l1 messages - std::array initial_l2_to_l1_messages{}; - initial_l2_to_l1_messages[0] = fr(1); + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_TX> initial_l2_to_l1_messages{}; + initial_l2_to_l1_messages[0].value = fr(1); inputs.previous_kernel.public_inputs.end.new_l2_to_l1_msgs = initial_l2_to_l1_messages; auto public_inputs = native_public_kernel_circuit_public_previous_kernel(dummyBuilder, inputs); @@ -1135,17 +1158,32 @@ TEST(public_kernel_tests, circuit_outputs_should_be_correctly_populated_with_pre expected_new_reads, public_inputs.end.public_data_reads)); - std::array const expected_new_commitments = + std::array, MAX_NEW_COMMITMENTS_PER_CALL> const expected_new_commitment_values = new_commitments_as_siloed_commitments(inputs.public_call.call_stack_item.public_inputs.new_commitments, contract_address); + // TODO(suyash): PublicKernelPublicInputs don't contain counters yet, so we initialise expected counters + // to be 0 (i.e. default value) for now. + std::array, MAX_NEW_COMMITMENTS_PER_CALL> expected_new_commitments{}; + for (size_t i = 0; i < MAX_NEW_COMMITMENTS_PER_CALL; ++i) { + expected_new_commitments[i] = expected_new_commitment_values[i]; + } + ASSERT_TRUE(source_arrays_are_in_target(dummyBuilder, inputs.previous_kernel.public_inputs.end.new_commitments, expected_new_commitments, public_inputs.end.new_commitments)); - std::array const expected_new_nullifiers = new_nullifiers_as_siloed_nullifiers( - inputs.public_call.call_stack_item.public_inputs.new_nullifiers, contract_address); + std::array, MAX_NEW_NULLIFIERS_PER_CALL> const expected_new_nullifier_values = + new_nullifiers_as_siloed_nullifiers(inputs.public_call.call_stack_item.public_inputs.new_nullifiers, + contract_address); + + // TODO(suyash): PublicKernelPublicInputs don't contain counters yet, so we initialise expected counters + // to be 0 for now. + std::array, MAX_NEW_NULLIFIERS_PER_CALL> expected_new_nullifiers{}; + for (size_t i = 0; i < MAX_NEW_NULLIFIERS_PER_CALL; ++i) { + expected_new_nullifiers[i] = expected_new_nullifier_values[i]; + } ASSERT_TRUE(source_arrays_are_in_target(dummyBuilder, inputs.previous_kernel.public_inputs.end.new_nullifiers, @@ -1156,13 +1194,20 @@ TEST(public_kernel_tests, circuit_outputs_should_be_correctly_populated_with_pre fr const chain_id = inputs.previous_kernel.public_inputs.constants.tx_context.chain_id; fr const version = inputs.previous_kernel.public_inputs.constants.tx_context.version; - std::array const expected_new_messages = + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> const expected_new_message_values = new_l2_messages_from_message(inputs.public_call.call_stack_item.public_inputs.new_l2_to_l1_msgs, contract_address, portal_contract_address, chain_id, version); + // TODO(suyash): PublicKernelPublicInputs don't contain counters yet, so we initialise expected counters + // to be 0 (i.e. default value) for now. + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> expected_new_messages{}; + for (size_t i = 0; i < MAX_NEW_L2_TO_L1_MSGS_PER_CALL; ++i) { + expected_new_messages[i] = expected_new_message_values[i]; + } + ASSERT_TRUE(source_arrays_are_in_target(dummyBuilder, inputs.previous_kernel.public_inputs.end.new_l2_to_l1_msgs, expected_new_messages, @@ -1217,7 +1262,7 @@ TEST(public_kernel_tests, public_kernel_fails_creating_new_commitments_on_static empty_array_of_values, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>(); // regenerate call data hash - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = get_call_stack_item_hash(inputs.public_call.call_stack_item); // Update call stack hash @@ -1240,10 +1285,10 @@ TEST(public_kernel_tests, public_kernel_fails_creating_new_nullifiers_on_static_ inputs.public_call.call_stack_item.public_inputs.contract_storage_update_requests = empty_array_of_values, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL>(); inputs.public_call.call_stack_item.public_inputs.new_commitments = - empty_array_of_values(); + empty_array_of_values, MAX_NEW_COMMITMENTS_PER_CALL>(); // regenerate call data hash - inputs.previous_kernel.public_inputs.end.public_call_stack[0] = + inputs.previous_kernel.public_inputs.end.public_call_stack[0].value = get_call_stack_item_hash(inputs.public_call.call_stack_item); // Update call stack hash diff --git a/circuits/cpp/src/aztec3/circuits/kernel/public/common.cpp b/circuits/cpp/src/aztec3/circuits/kernel/public/common.cpp index bd08b4c5bdbf..d5160acac21b 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/public/common.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/public/common.cpp @@ -57,7 +57,7 @@ void validate_this_public_call_hash(DummyBuilder& builder, // TODO: this logic might need to change to accommodate the weird edge 3 initial txs (the 'main' tx, the 'fee' tx, // and the 'gas rebate' tx). - const auto popped_public_call_hash = array_pop(public_inputs.end.public_call_stack); + const auto popped_public_call_hash = array_pop(public_inputs.end.public_call_stack).value; const auto calculated_this_public_call_hash = get_call_stack_item_hash(public_kernel_inputs.public_call.call_stack_item); diff --git a/circuits/cpp/src/aztec3/circuits/kernel/public/common.hpp b/circuits/cpp/src/aztec3/circuits/kernel/public/common.hpp index 7ee34f3d6144..bfb3b50620f0 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/public/common.hpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/public/common.hpp @@ -5,6 +5,7 @@ #include "aztec3/circuits/abis/kernel_circuit_public_inputs.hpp" #include "aztec3/circuits/abis/public_data_update_request.hpp" #include "aztec3/circuits/abis/public_kernel/public_kernel_inputs.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/utils/array.hpp" #include "aztec3/utils/dummy_circuit_builder.hpp" @@ -15,6 +16,8 @@ using NT = aztec3::utils::types::NativeTypes; using aztec3::circuits::abis::KernelCircuitPublicInputs; using aztec3::circuits::abis::PublicDataRead; using aztec3::circuits::abis::PublicDataUpdateRequest; +using aztec3::circuits::abis::SideEffect; +using aztec3::circuits::abis::SideEffectLinkedToNoteHash; using aztec3::circuits::abis::public_kernel::PublicKernelInputs; using DummyBuilder = aztec3::utils::DummyCircuitBuilder; using aztec3::utils::array_length; @@ -49,7 +52,7 @@ void common_validate_call_stack(DummyBuilder& builder, KernelInput const& public // Note: this assumes it's computationally infeasible to have `0` as a valid call_stack_item_hash. // Assumes `hash == 0` means "this stack item is empty". - if (hash == 0) { + if (hash.is_empty()) { continue; } @@ -59,7 +62,7 @@ void common_validate_call_stack(DummyBuilder& builder, KernelInput const& public const auto calculated_hash = preimage.hash(); builder.do_assert( - hash == calculated_hash, + hash.value == calculated_hash, format( "public_call_stack[", i, "] = ", hash, "; does not reconcile with calculatedHash = ", calculated_hash), CircuitErrorCode::PUBLIC_KERNEL__PUBLIC_CALL_STACK_MISMATCH); @@ -294,11 +297,13 @@ void propagate_new_commitments(Builder& builder, const auto& new_commitments = public_call_public_inputs.new_commitments; const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address; - std::array siloed_new_commitments{}; + std::array, MAX_NEW_COMMITMENTS_PER_CALL> siloed_new_commitments{}; for (size_t i = 0; i < new_commitments.size(); ++i) { - if (!new_commitments[i].is_zero()) { - siloed_new_commitments[i] = silo_commitment(storage_contract_address, new_commitments[i]); - } + const auto& commitment = new_commitments[i]; + siloed_new_commitments[i] = SideEffect{ + .value = commitment.value == 0 ? 0 : silo_commitment(storage_contract_address, commitment.value), + .side_effect_counter = commitment.side_effect_counter, + }; } push_array_to_array(builder, @@ -326,13 +331,22 @@ void propagate_new_nullifiers(Builder& builder, const auto& new_nullifiers = public_call_public_inputs.new_nullifiers; const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address; - std::array siloed_new_nullifiers{}; - for (size_t i = 0; i < new_nullifiers.size(); ++i) { - if (!new_nullifiers[i].is_zero()) { - siloed_new_nullifiers[i] = silo_nullifier(storage_contract_address, new_nullifiers[i]); - } + // nullifiers + std::array, MAX_NEW_NULLIFIERS_PER_CALL> siloed_new_nullifiers{}; + for (size_t i = 0; i < MAX_NEW_NULLIFIERS_PER_CALL; ++i) { + const auto& nullifier = new_nullifiers[i]; + + const auto& siloed_note_hash = nullifier.note_hash == fr(0) + ? fr(0) // don't silo when empty + : nullifier.note_hash == fr(EMPTY_NULLIFIED_COMMITMENT) + ? fr(EMPTY_NULLIFIED_COMMITMENT) // don't silo when empty + : silo_commitment(storage_contract_address, nullifier.note_hash); + siloed_new_nullifiers[i] = SideEffectLinkedToNoteHash{ + .value = nullifier.value == 0 ? 0 : silo_nullifier(storage_contract_address, nullifier.value), + .note_hash = siloed_note_hash, + .side_effect_counter = nullifier.side_effect_counter, + }; } - push_array_to_array(builder, siloed_new_nullifiers, circuit_outputs.end.new_nullifiers, @@ -358,21 +372,25 @@ void propagate_new_l2_to_l1_messages(Builder& builder, const auto& storage_contract_address = public_call_public_inputs.call_context.storage_contract_address; const auto& new_l2_to_l1_msgs = public_call_public_inputs.new_l2_to_l1_msgs; - std::array new_l2_to_l1_msgs_to_insert{}; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_CALL> new_l2_to_l1_msgs_to_insert{}; for (size_t i = 0; i < new_l2_to_l1_msgs.size(); ++i) { - if (!new_l2_to_l1_msgs[i].is_zero()) { + const auto& msg = new_l2_to_l1_msgs[i]; + if (!msg.value.is_zero()) { const auto chain_id = public_kernel_inputs.previous_kernel.public_inputs.constants.tx_context.chain_id; const auto version = public_kernel_inputs.previous_kernel.public_inputs.constants.tx_context.version; - new_l2_to_l1_msgs_to_insert[i] = compute_l2_to_l1_hash( - storage_contract_address, version, portal_contract_address, chain_id, new_l2_to_l1_msgs[i]); + new_l2_to_l1_msgs_to_insert[i] = SideEffect{ + .value = compute_l2_to_l1_hash( + storage_contract_address, version, portal_contract_address, chain_id, msg.value), + .side_effect_counter = msg.side_effect_counter, + }; } + push_array_to_array( + builder, + new_l2_to_l1_msgs_to_insert, + circuit_outputs.end.new_l2_to_l1_msgs, + format(PUBLIC_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "too many new l2 to l1 messages in one tx")); } - push_array_to_array( - builder, - new_l2_to_l1_msgs_to_insert, - circuit_outputs.end.new_l2_to_l1_msgs, - format(PUBLIC_KERNEL_CIRCUIT_ERROR_MESSAGE_BEGINNING, "too many new l2 to l1 messages in one tx")); } /** diff --git a/circuits/cpp/src/aztec3/circuits/rollup/base/.test.cpp b/circuits/cpp/src/aztec3/circuits/rollup/base/.test.cpp index 9e14512f24c0..cc332b904321 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/base/.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/base/.test.cpp @@ -10,6 +10,7 @@ #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/public_data_read.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/circuits/kernel/private/utils.hpp" #include "aztec3/circuits/rollup/components/components.hpp" @@ -260,9 +261,9 @@ TEST_F(base_rollup_tests, native_new_commitments_tree) std::array, 2> kernel_data = { get_empty_kernel(), get_empty_kernel() }; std::array new_commitments = { 0, 1, 2, 3, 4, 5, 6, 7 }; for (uint8_t i = 0; i < 2; i++) { - std::array kernel_commitments; + std::array, MAX_NEW_COMMITMENTS_PER_TX> kernel_commitments; for (uint8_t j = 0; j < MAX_NEW_COMMITMENTS_PER_TX; j++) { - kernel_commitments[j] = new_commitments[i * MAX_NEW_COMMITMENTS_PER_TX + j]; + kernel_commitments[j].value = new_commitments[i * MAX_NEW_COMMITMENTS_PER_TX + j]; } kernel_data[i].public_inputs.end.new_commitments = kernel_commitments; } @@ -375,9 +376,9 @@ void nullifier_insertion_test(std::array new_ DummyCircuitBuilder builder = DummyCircuitBuilder("base_rollup_tests__nullifier_insertion_test"); std::array, 2> kernel_data = { get_empty_kernel(), get_empty_kernel() }; for (uint8_t i = 0; i < 2; i++) { - std::array kernel_nullifiers; + std::array, MAX_NEW_NULLIFIERS_PER_TX> kernel_nullifiers; for (uint8_t j = 0; j < MAX_NEW_NULLIFIERS_PER_TX; j++) { - kernel_nullifiers[j] = new_nullifiers[i * MAX_NEW_NULLIFIERS_PER_TX + j]; + kernel_nullifiers[j].value = new_nullifiers[i * MAX_NEW_NULLIFIERS_PER_TX + j]; } kernel_data[i].public_inputs.end.new_nullifiers = kernel_nullifiers; } @@ -418,10 +419,10 @@ TEST_F(base_rollup_tests, native_new_nullifier_tree_sparse_insertions) TEST_F(base_rollup_tests, native_new_nullifier_tree_sparse) { - std::array nullifiers; + std::array, 2 * MAX_NEW_NULLIFIERS_PER_TX> nullifiers; for (size_t i = 0; i < nullifiers.size(); i++) { - nullifiers[i] = 2 * MAX_NEW_NULLIFIERS_PER_TX + 5 * i + 1; + nullifiers[i].value = 2 * MAX_NEW_NULLIFIERS_PER_TX + 5 * i + 1; } std::vector initial_values(2 * MAX_NEW_NULLIFIERS_PER_TX - 1); @@ -433,7 +434,7 @@ TEST_F(base_rollup_tests, native_new_nullifier_tree_sparse) auto nullifier_tree = get_initial_nullifier_tree(initial_values); auto expected_start_nullifier_tree_snapshot = nullifier_tree.get_snapshot(); for (auto v : nullifiers) { - nullifier_tree.update_element(v); + nullifier_tree.update_element(v.value); } auto expected_end_nullifier_tree_snapshot = nullifier_tree.get_snapshot(); @@ -481,14 +482,14 @@ TEST_F(base_rollup_tests, native_nullifier_tree_regression) initial_values[7] = uint256_t("2bb9aa4a22a6ae7204f2c67abaab59cead6558cde4ee25ce3464704cb2e38136"); initial_values[8] = uint256_t("16a732095298ccca828c4d747813f8bd46e188079ed17904e2c9de50760833c8"); - std::array new_nullifiers = { 0 }; - new_nullifiers[0] = uint256_t("16da4f27fb78de7e0db4c5a04b569bc46382c5f471da2f7d670beff1614e0118"), - new_nullifiers[1] = uint256_t("26ab07ce103a55e29f11478eaa36cebd10c4834b143a7debcc7ef53bfdb547dd"); + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers{}; + new_nullifiers[0].value = uint256_t("16da4f27fb78de7e0db4c5a04b569bc46382c5f471da2f7d670beff1614e0118"), + new_nullifiers[1].value = uint256_t("26ab07ce103a55e29f11478eaa36cebd10c4834b143a7debcc7ef53bfdb547dd"); auto nullifier_tree = get_initial_nullifier_tree(initial_values); auto expected_start_nullifier_tree_snapshot = nullifier_tree.get_snapshot(); for (auto v : new_nullifiers) { - nullifier_tree.update_element(v); + nullifier_tree.update_element(v.value); } auto expected_end_nullifier_tree_snapshot = nullifier_tree.get_snapshot(); @@ -550,10 +551,10 @@ TEST_F(base_rollup_tests, native_new_nullifier_tree_double_spend) fr const nullifier_to_insert = 2 * MAX_NEW_NULLIFIERS_PER_TX + 4; // arbitrary value greater than 2 * MAX_NEW_NULLIFIERS_PER_TX - std::array new_nullifiers{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers{}; - new_nullifiers[0] = nullifier_to_insert; - new_nullifiers[2] = nullifier_to_insert; + new_nullifiers[0].value = nullifier_to_insert; + new_nullifiers[2].value = nullifier_to_insert; std::tuple, AppendOnlyTreeSnapshot> inputs_and_snapshots = test_utils::utils::generate_nullifier_tree_testing_values(empty_inputs, new_nullifiers, 1); @@ -592,8 +593,8 @@ TEST_F(base_rollup_tests, native_calldata_hash) // Commitments inserted are [1,2,3,4,5,6,7,8 ...]. Nullifiers inserted are [8,9,10,11,12,13,14,15 ...] for (size_t i = 0; i < 2; ++i) { for (size_t j = 0; j < MAX_NEW_NULLIFIERS_PER_TX; j++) { - kernel_data[i].public_inputs.end.new_commitments[j] = fr(i * MAX_NEW_NULLIFIERS_PER_TX + j + 1); - kernel_data[i].public_inputs.end.new_nullifiers[j] = fr((2 + i) * MAX_NEW_NULLIFIERS_PER_TX + j); + kernel_data[i].public_inputs.end.new_commitments[j].value = fr(i * MAX_NEW_NULLIFIERS_PER_TX + j + 1); + kernel_data[i].public_inputs.end.new_nullifiers[j].value = fr((2 + i) * MAX_NEW_NULLIFIERS_PER_TX + j); } } diff --git a/circuits/cpp/src/aztec3/circuits/rollup/base/native_base_rollup_circuit.cpp b/circuits/cpp/src/aztec3/circuits/rollup/base/native_base_rollup_circuit.cpp index efed2fb3d5d6..9367ef02981c 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/base/native_base_rollup_circuit.cpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/base/native_base_rollup_circuit.cpp @@ -117,7 +117,7 @@ NT::fr calculate_commitments_subtree(DummyBuilder& builder, BaseRollupInputs con for (size_t j = 0; j < new_commitments.size(); j++) { // todo: batch insert - commitments_tree.update_element(i * MAX_NEW_COMMITMENTS_PER_TX + j, new_commitments[j]); + commitments_tree.update_element(i * MAX_NEW_COMMITMENTS_PER_TX + j, new_commitments[j].value); } } @@ -228,7 +228,7 @@ AppendOnlySnapshot check_nullifier_tree_non_membership_and_insert_to_tree(DummyB // Preimage of the lo-index required for a non-membership proof auto low_nullifier_preimage = baseRollupInputs.low_nullifier_leaf_preimages[nullifier_index]; // Newly created nullifier - auto nullifier = new_nullifiers[j]; + auto nullifier = new_nullifiers[j].value; // TODO(maddiaa): reason about this more strongly, can this cause issues? if (nullifier != 0) { diff --git a/circuits/cpp/src/aztec3/circuits/rollup/components/components.cpp b/circuits/cpp/src/aztec3/circuits/rollup/components/components.cpp index 54ab4c1b3ea2..3e9f37483140 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/components/components.cpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/components/components.cpp @@ -111,6 +111,7 @@ std::array compute_kernels_calldata_hash( // 2 contract deployments (1 per kernel) -> 6 fields // 2 encrypted logs hashes (1 per kernel) -> 4 fields --> 2 sha256 hashes --> 64 bytes // 2 unencrypted logs hashes (1 per kernel) -> 4 fields --> 2 sha256 hashes --> 64 bytes + // TODO(dbanks12): should this hash include side effect counters? auto const number_of_inputs = (MAX_NEW_COMMITMENTS_PER_TX + MAX_NEW_NULLIFIERS_PER_TX + MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * 2 + MAX_NEW_L2_TO_L1_MSGS_PER_TX + MAX_NEW_CONTRACTS_PER_TX * 3 + @@ -130,12 +131,12 @@ std::array compute_kernels_calldata_hash( size_t offset = 0; for (size_t j = 0; j < MAX_NEW_COMMITMENTS_PER_TX; j++) { - calldata_hash_inputs[offset + i * MAX_NEW_COMMITMENTS_PER_TX + j] = new_commitments[j]; + calldata_hash_inputs[offset + i * MAX_NEW_COMMITMENTS_PER_TX + j] = new_commitments[j].value; } offset += MAX_NEW_COMMITMENTS_PER_TX * 2; for (size_t j = 0; j < MAX_NEW_NULLIFIERS_PER_TX; j++) { - calldata_hash_inputs[offset + i * MAX_NEW_NULLIFIERS_PER_TX + j] = new_nullifiers[j]; + calldata_hash_inputs[offset + i * MAX_NEW_NULLIFIERS_PER_TX + j] = new_nullifiers[j].value; } offset += MAX_NEW_NULLIFIERS_PER_TX * 2; @@ -148,7 +149,7 @@ std::array compute_kernels_calldata_hash( offset += MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX * 2 * 2; for (size_t j = 0; j < MAX_NEW_L2_TO_L1_MSGS_PER_TX; j++) { - calldata_hash_inputs[offset + i * MAX_NEW_L2_TO_L1_MSGS_PER_TX + j] = newL2ToL1msgs[j]; + calldata_hash_inputs[offset + i * MAX_NEW_L2_TO_L1_MSGS_PER_TX + j] = newL2ToL1msgs[j].value; } offset += MAX_NEW_L2_TO_L1_MSGS_PER_TX * 2; diff --git a/circuits/cpp/src/aztec3/circuits/rollup/root/.test.cpp b/circuits/cpp/src/aztec3/circuits/rollup/root/.test.cpp index aff8660d432b..fb586849e3bc 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/root/.test.cpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/root/.test.cpp @@ -9,6 +9,7 @@ #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/previous_kernel_data.hpp" #include "aztec3/circuits/abis/rollup/merge/previous_rollup_data.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/circuits/kernel/private/utils.hpp" #include "aztec3/circuits/rollup/base/init.hpp" @@ -198,18 +199,18 @@ TEST_F(root_rollup_tests, native_root_missing_nullifier_logic) // Create commitments for (size_t kernel_j = 0; kernel_j < 4; kernel_j++) { - std::array new_commitments; + std::array, MAX_NEW_COMMITMENTS_PER_TX> new_commitments; for (uint8_t commitment_k = 0; commitment_k < MAX_NEW_COMMITMENTS_PER_TX; commitment_k++) { auto val = fr(kernel_j * MAX_NEW_COMMITMENTS_PER_TX + commitment_k + 1); - new_commitments[commitment_k] = val; + new_commitments[commitment_k].value = val; private_data_tree.update_element(kernel_j * MAX_NEW_COMMITMENTS_PER_TX + commitment_k, val); } kernels[kernel_j].public_inputs.end.new_commitments = new_commitments; - std::array new_l2_to_l1_messages; + std::array, MAX_NEW_L2_TO_L1_MSGS_PER_TX> new_l2_to_l1_messages; for (uint8_t i = 0; i < MAX_NEW_L2_TO_L1_MSGS_PER_TX; i++) { auto val = fr(kernel_j * MAX_NEW_L2_TO_L1_MSGS_PER_TX + i + 1); - new_l2_to_l1_messages[i] = val; + new_l2_to_l1_messages[i].value = val; } kernels[kernel_j].public_inputs.end.new_l2_to_l1_msgs = new_l2_to_l1_messages; } diff --git a/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.cpp b/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.cpp index 0727fe73ae8e..4185edf33985 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.cpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.cpp @@ -6,6 +6,7 @@ #include "aztec3/circuits/abis/membership_witness.hpp" #include "aztec3/circuits/abis/new_contract_data.hpp" #include "aztec3/circuits/abis/rollup/root/root_rollup_public_inputs.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/circuits/kernel/private/utils.hpp" #include "aztec3/circuits/rollup/base/init.hpp" @@ -108,7 +109,7 @@ BaseRollupInputs base_rollup_inputs_from_kernels(std::array kerne initial_values[i] = i + 1; } - std::array nullifiers; + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> nullifiers; for (size_t i = 0; i < 2; i++) { for (size_t j = 0; j < MAX_NEW_NULLIFIERS_PER_TX; j++) { nullifiers[i * MAX_NEW_NULLIFIERS_PER_TX + j] = kernel_data[i].public_inputs.end.new_nullifiers[j]; @@ -300,19 +301,19 @@ std::array, 2> get_previous_rollup_data(DummyBuilder& bui for (size_t i = 0; i < initial_values.size(); i++) { initial_values[i] = i + 1; } - std::array nullifiers; + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> nullifiers; for (size_t i = 0; i < 2; i++) { for (size_t j = 0; j < MAX_NEW_COMMITMENTS_PER_TX; j++) { private_data_tree.update_element(i * MAX_NEW_COMMITMENTS_PER_TX + j, - kernel_data[i].public_inputs.end.new_commitments[j]); + kernel_data[i].public_inputs.end.new_commitments[j].value); } auto contract_data = kernel_data[i].public_inputs.end.new_contracts[0]; if (!contract_data.is_empty()) { contract_tree.update_element(i, contract_data.hash()); } for (size_t j = 0; j < MAX_NEW_NULLIFIERS_PER_TX; j++) { - initial_values.push_back(kernel_data[i].public_inputs.end.new_nullifiers[j]); + initial_values.push_back(kernel_data[i].public_inputs.end.new_nullifiers[j].value); nullifiers[i * MAX_NEW_NULLIFIERS_PER_TX + j] = kernel_data[2 + i].public_inputs.end.new_nullifiers[j]; } } @@ -459,10 +460,10 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values(BaseRollupI size_t spacing = 5) { const size_t NUMBER_OF_NULLIFIERS = MAX_NEW_NULLIFIERS_PER_TX * 2; - std::array nullifiers; + std::array, NUMBER_OF_NULLIFIERS> nullifiers; for (size_t i = 0; i < NUMBER_OF_NULLIFIERS; ++i) { auto insertion_val = (starting_insertion_value + i * spacing); - nullifiers[i] = fr(insertion_val); + nullifiers[i].value = fr(insertion_val); } // Generate initial values lin spaved @@ -475,7 +476,9 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values(BaseRollupI } nullifier_tree_testing_values generate_nullifier_tree_testing_values( - BaseRollupInputs inputs, std::array new_nullifiers, size_t spacing = 5) + BaseRollupInputs inputs, + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers, + size_t spacing = 5) { // Generate initial values lin spaced std::vector initial_values; @@ -488,7 +491,7 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values( nullifier_tree_testing_values generate_nullifier_tree_testing_values_explicit( BaseRollupInputs rollupInputs, - std::array new_nullifiers, + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers, const std::vector& initial_values) { size_t const start_tree_size = initial_values.size() + 1; @@ -504,8 +507,8 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values_explicit( // Calculate the predecessor nullifier pre-images // Get insertion values std::vector insertion_values; - std::array new_nullifiers_kernel_1{}; - std::array new_nullifiers_kernel_2{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers_kernel_1{}; + std::array, MAX_NEW_NULLIFIERS_PER_TX> new_nullifiers_kernel_2{}; for (size_t i = 0; i < NUMBER_OF_NULLIFIERS; ++i) { auto insertion_val = new_nullifiers[i]; @@ -514,8 +517,8 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values_explicit( } else { new_nullifiers_kernel_2[i - MAX_NEW_NULLIFIERS_PER_TX] = insertion_val; } - insertion_values.push_back(insertion_val); - reference_tree.update_element(insertion_val); + insertion_values.push_back(insertion_val.value); + reference_tree.update_element(insertion_val.value); } // Get the hash paths etc from the insertion values diff --git a/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.hpp b/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.hpp index 64775772657a..6013ddc4c17e 100644 --- a/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.hpp +++ b/circuits/cpp/src/aztec3/circuits/rollup/test_utils/utils.hpp @@ -3,6 +3,7 @@ #include "nullifier_tree_testing_harness.hpp" #include "aztec3/circuits/abis/public_data_update_request.hpp" +#include "aztec3/circuits/abis/side_effects.hpp" #include "aztec3/circuits/hash.hpp" #include "aztec3/constants.hpp" @@ -82,7 +83,7 @@ abis::AppendOnlyTreeSnapshot get_snapshot_of_tree_state(NullifierMemoryTreeT nullifier_tree_testing_values generate_nullifier_tree_testing_values_explicit( BaseRollupInputs inputs, - std::array new_nullifiers, + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers, const std::vector& initial_values); nullifier_tree_testing_values generate_nullifier_tree_testing_values(BaseRollupInputs inputs, @@ -92,7 +93,9 @@ nullifier_tree_testing_values generate_nullifier_tree_testing_values(BaseRollupI std::array get_empty_l1_to_l2_messages(); nullifier_tree_testing_values generate_nullifier_tree_testing_values( - BaseRollupInputs inputs, std::array new_nullifiers, size_t spacing); + BaseRollupInputs inputs, + std::array, MAX_NEW_NULLIFIERS_PER_TX * 2> new_nullifiers, + size_t spacing); NullifierMemoryTreeTestingHarness get_initial_nullifier_tree_empty(); NullifierMemoryTreeTestingHarness get_initial_nullifier_tree(const std::vector& initial_values); diff --git a/circuits/cpp/src/aztec3/constants.hpp b/circuits/cpp/src/aztec3/constants.hpp index 4f90a329345d..8cac71d1729e 100644 --- a/circuits/cpp/src/aztec3/constants.hpp +++ b/circuits/cpp/src/aztec3/constants.hpp @@ -231,39 +231,57 @@ constexpr size_t HISTORIC_BLOCK_DATA_LENGTH = 7; constexpr size_t FUNCTION_DATA_LENGTH = 4; constexpr size_t CONTRACT_DEPLOYMENT_DATA_LENGTH = 6; +constexpr size_t SIDE_EFFECT_LENGTH = 2; +constexpr size_t SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH = 3; +constexpr size_t SIDE_EFFECT_WITH_RANGE_LENGTH = 3; + // Change this ONLY if you have changed the PrivateCircuitPublicInputs structure in C++. // In other words, if the structure/size of the public inputs of a function call changes then we // should change this constant as well as the offsets in private_call_stack_item.nr constexpr size_t PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 1 // +1 for args_hash - + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL + MAX_NEW_COMMITMENTS_PER_CALL + - 2 * MAX_NEW_NULLIFIERS_PER_CALL + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + - MAX_NEW_L2_TO_L1_MSGS_PER_CALL + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + 2 // + 2 for logs preimage lengths - + HISTORIC_BLOCK_DATA_LENGTH + CONTRACT_DEPLOYMENT_DATA_LENGTH + 2; // + 2 for chain_id and version + + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + MAX_NEW_NULLIFIERS_PER_CALL + + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + + MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + + 2 // + 2 for logs preimage lengths + + HISTORIC_BLOCK_DATA_LENGTH + CONTRACT_DEPLOYMENT_DATA_LENGTH + 2; // + 2 for chain_id and version constexpr size_t PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 1 + 1 // call_context_hash + args_hash - + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL + MAX_NEW_COMMITMENTS_PER_CALL + - 2 * MAX_NEW_NULLIFIERS_PER_CALL + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + - MAX_NEW_L2_TO_L1_MSGS_PER_CALL + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + 2 // + 2 for logs preimage lengths + + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + MAX_NEW_NULLIFIERS_PER_CALL + + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + // *3 for start/end sideeffect counters + MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + // *2 for sideeffect counter + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + 2 // + 2 for logs preimage lengths + HISTORIC_BLOCK_DATA_LENGTH + 3; // + 3 for contract_deployment_data.hash(), chain_id, version -constexpr size_t CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 3; -constexpr size_t CONTRACT_STORAGE_READ_LENGTH = 2; +constexpr size_t CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 4; +constexpr size_t CONTRACT_STORAGE_READ_LENGTH = 3; // Change this ONLY if you have changed the PublicCircuitPublicInputs structure in C++. constexpr size_t PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = CALL_CONTEXT_LENGTH + 1 + RETURN_VALUES_LENGTH + // + 1 for args_hash MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL * CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH + - MAX_PUBLIC_DATA_READS_PER_CALL * CONTRACT_STORAGE_READ_LENGTH + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + - MAX_NEW_COMMITMENTS_PER_CALL + MAX_NEW_NULLIFIERS_PER_CALL + MAX_NEW_L2_TO_L1_MSGS_PER_CALL + - NUM_FIELDS_PER_SHA256 + 1 + // + 1 for unencrypted logs preimage length + MAX_PUBLIC_DATA_READS_PER_CALL * CONTRACT_STORAGE_READ_LENGTH + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + + MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + + MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + NUM_FIELDS_PER_SHA256 + + 1 + // + 1 for unencrypted logs preimage length HISTORIC_BLOCK_DATA_LENGTH + 2; // + 2 for chain_id and version constexpr size_t PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 2 + RETURN_VALUES_LENGTH + // + 1 for args_hash + 1 call_context.hash - MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL + MAX_PUBLIC_DATA_READS_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + - MAX_NEW_COMMITMENTS_PER_CALL + MAX_NEW_NULLIFIERS_PER_CALL + MAX_NEW_L2_TO_L1_MSGS_PER_CALL + + MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL + MAX_PUBLIC_DATA_READS_PER_CALL + + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + + MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + + MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + NUM_FIELDS_PER_SHA256 + // unencrypted_logs_hash (being represented by NUM_FIELDS_PER_SHA256) HISTORIC_BLOCK_DATA_LENGTH + 2; // unencrypted_log_preimages_length + prover_address diff --git a/circuits/cpp/src/aztec3/utils/array.hpp b/circuits/cpp/src/aztec3/utils/array.hpp index 0134e7e30ad8..c4f528ac41d5 100644 --- a/circuits/cpp/src/aztec3/utils/array.hpp +++ b/circuits/cpp/src/aztec3/utils/array.hpp @@ -1,4 +1,5 @@ #pragma once +#include "./types/circuit_types.hpp" #include "./types/native_types.hpp" #include "aztec3/utils/circuit_errors.hpp" @@ -250,4 +251,166 @@ bool source_arrays_are_in_target(Builder& builder, return true; } +// TODO(suyash): Need this function to support NT::fr as well as circuit types. +template +typename types::CircuitTypes::boolean aztec_circuit_is_empty(T const& value) +{ + using CT = types::CircuitTypes; + using boolean = typename CT::boolean; + + if constexpr (std::is_same::value) { + return boolean(value == NT::fr(0)); + } else { + return value.is_empty(); + } +} + +/** + * Gets the number of contiguous nonzero values of an array from the start. + * Note: This assumes `0` always means 'not used', so be careful. As soon as we locate 0, we stop the counting. + * If you actually want `0` to be counted, you'll need something else. + */ +template +typename types::CircuitTypes::fr aztec_circuit_array_length(std::array const& arr) +{ + using CT = types::CircuitTypes; + using fr = typename CT::fr; + using boolean = typename CT::boolean; + + fr length = 0; + boolean hit_zero = false; + for (const auto& e : arr) { + boolean is_zero = aztec_circuit_is_empty(e); + hit_zero.must_imply(is_zero, "Once we've hit the first zero, there must only be zeros thereafter!"); + hit_zero |= is_zero; + const fr increment = !hit_zero; + length += increment; + } + return length; +}; + +/** + * Note: doesn't remove the last element from the array; only returns it! + * Note: this assumes `0` always means 'not used', so be careful. If you actually want `0` to be counted, you'll need + * something else. + * If it returns `0`, the array is considered 'empty'. + */ +template T aztec_circuit_array_pop(std::array const& arr) +{ + using CT = types::CircuitTypes; + using boolean = typename CT::boolean; + + T popped_value{}; + boolean already_popped = false; + for (size_t i = arr.size() - 1; i != (size_t)-1; i--) { + boolean is_non_zero = !aztec_circuit_is_empty(arr[i]); + popped_value = T::conditional_assign(!already_popped && is_non_zero, arr[i], popped_value); + + already_popped |= is_non_zero; + } + already_popped.assert_equal(true, "array_pop cannot pop from an empty array"); + + return popped_value; +}; + +// TODO(dbanks12): should be able to move this into bberg +// real circuit stuff +template +void aztec_circuit_array_push(std::array& arr, T const& value) +{ + using CT = types::CircuitTypes; + using boolean = typename CT::boolean; + + boolean already_pushed = false; + for (size_t i = 0; i < arr.size(); ++i) { + boolean is_empty = arr[i].is_empty(); + arr[i] = T::conditional_assign(!already_pushed && is_empty, value, arr[i]); + + already_pushed |= is_empty; + } + already_pushed.assert_equal(true, "array_push cannot push to a full array"); +}; + +// TODO(suyash): Do we really need this for optional type? +template +void aztec_circuit_array_push(std::array, SIZE>& arr, T const& value) +{ + using CT = types::CircuitTypes; + using boolean = typename CT::boolean; + + boolean already_pushed = false; + for (size_t i = 0; i < arr.size(); ++i) { + boolean is_empty = true; + if (arr[i].has_value()) { + is_empty = arr[i].value().is_empty(); + arr[i] = T::conditional_assign(!already_pushed && is_empty, value, arr[i].value()); + } + + already_pushed |= is_empty; + } + already_pushed.assert_equal(true, "array_push cannot push to a full array"); +}; + +template +typename types::CircuitTypes::boolean aztec_circuit_is_array_empty(std::array const& arr) +{ + using CT = types::CircuitTypes; + using boolean = typename CT::boolean; + + boolean nonzero_found = false; + for (size_t i = arr.size() - 1; i != (size_t)-1; i--) { + boolean is_non_empty = !arr[i].is_empty(); + nonzero_found |= is_non_empty; + } + return !nonzero_found; +}; + +template +void aztec_circuit_push_array_to_array(std::array const& source, std::array& target) +{ + using CT = types::CircuitTypes; + using fr = typename CT::fr; + using boolean = typename CT::boolean; + + fr target_length = aztec_circuit_array_length(target); + const fr overflow_capacity = target.max_size() + 1; + + fr j_ct = 0; // circuit-type index for the inner loop + // Find the first empty slot in the target: + fr next_target_index = target_length; + + boolean hit_s_zero = false; + boolean not_hit_s_zero = true; + + for (size_t i = 0; i < source.max_size(); ++i) { + // Loop over each source value we want to push: + auto& s = source[i]; + { + auto is_s_zero = s.is_empty(); + hit_s_zero.must_imply(is_s_zero, + "Once we've hit the first source zero, there must only be zeros thereafter!"); + hit_s_zero |= is_s_zero; + not_hit_s_zero = !hit_s_zero; + } + + // Triangular loop: + for (size_t j = i; j < target.max_size(); ++j) { + auto& t = target[j]; + + // Check whether we've reached the next target index at which we can push `s`: + boolean at_next_target_index = j_ct == next_target_index; + + t = T::conditional_assign(at_next_target_index && not_hit_s_zero, s, t); + + j_ct++; + } + + next_target_index += not_hit_s_zero; + + next_target_index.assert_not_equal(overflow_capacity, "push_array_to_array target array capacity exceeded"); + + j_ct = i + 1; + } +} + } // namespace aztec3::utils diff --git a/yarn-project/aztec-nr/aztec/src/abi.nr b/yarn-project/aztec-nr/aztec/src/abi.nr index 656aaf47f79c..821bde4c3946 100644 --- a/yarn-project/aztec-nr/aztec/src/abi.nr +++ b/yarn-project/aztec-nr/aztec/src/abi.nr @@ -1,4 +1,5 @@ use crate::constants_gen::{ + EMPTY_NULLIFIED_COMMITMENT, RETURN_VALUES_LENGTH, MAX_READ_REQUESTS_PER_CALL, MAX_NEW_COMMITMENTS_PER_CALL, @@ -61,6 +62,74 @@ impl PublicGlobalVariables { } } +struct SideEffect { + value: Field, + side_effect_counter: Field, +} +impl SideEffect { + fn serialize(self) -> [Field; 2] { + [self.value, self.side_effect_counter] + } + //fn hash(self) -> Field { + // // no generator index to hash these... + // dep::std::hash::pedersen_with_separator(self.serialize(), 2)[0] + //} + fn empty() -> Self { + Self { + value: 0, + side_effect_counter: 0, + } + } +} + +// like read, nullifier, and possibly encrypted logs +// (they may be linked to a note / note-hash) +struct SideEffectLinkedToNoteHash { + value: Field, + note_hash: Field, // e.g. noteHash + side_effect_counter: Field, +} + +impl SideEffectLinkedToNoteHash { + fn serialize(self) -> [Field; 3] { + [self.value, self.note_hash, self.side_effect_counter] + } + //fn hash(self) -> Field { + // // no generator index to hash these... + // dep::std::hash::pedersen_with_separator(self.serialize(), 3)[0] + //} + fn empty() -> Self { + Self { + value: 0, + note_hash: 0, + side_effect_counter: 0, + } + } +} + +struct SideEffectWithRange { + value: Field, + start_side_effect_counter: Field, + end_side_effect_counter: Field, +} + +impl SideEffectWithRange { + fn serialize(self) -> [Field; 3] { + [self.value, self.start_side_effect_counter, self.end_side_effect_counter] + } + //fn hash(self) -> Field { + // // no generator index to hash these... + // dep::std::hash::pedersen_with_separator(self.serialize(), 3)[0] + //} + fn empty() -> Self { + Self { + value: 0, + start_side_effect_counter: 0, + end_side_effect_counter: 0, + } + } +} + // docs:start:contract-deployment-data struct ContractDeploymentData { deployer_public_key: Point, @@ -95,6 +164,8 @@ struct PrivateContextInputs { block_data: HistoricBlockData, contract_deployment_data: ContractDeploymentData, private_global_variables: PrivateGlobalVariables, + + start_side_effect_counter: Field, } // docs:end:private-context-inputs @@ -105,6 +176,8 @@ struct PublicContextInputs { block_data: HistoricBlockData, public_global_variables: PublicGlobalVariables, + + start_side_effect_counter: Field, } // docs:end:public-context-inputs @@ -190,13 +263,13 @@ struct PrivateCircuitPublicInputs { call_context: CallContext, args_hash: Field, return_values: [Field; RETURN_VALUES_LENGTH], - read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL], - new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL], - new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL], + read_requests: [SideEffect; crate::abi::MAX_READ_REQUESTS_PER_CALL], + new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL], + new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL], nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL], - private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], - public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], - new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], + private_call_stack: [SideEffectWithRange; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], + public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], + new_l2_to_l1_msgs: [SideEffect; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that // we're talking about a single number backed by two field elements. encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256], @@ -215,13 +288,13 @@ impl PrivateCircuitPublicInputs { fields.push(self.call_context.hash()); fields.push(self.args_hash); fields.push_array(self.return_values); - fields.push_array(self.read_requests); - fields.push_array(self.new_commitments); - fields.push_array(self.new_nullifiers); + fields.flatten_and_push_array(SideEffect::serialize, self.read_requests); + fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments); + fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers); fields.push_array(self.nullified_commitments); - fields.push_array(self.private_call_stack); - fields.push_array(self.public_call_stack); - fields.push_array(self.new_l2_to_l1_msgs); + fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack); + fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack); + fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs); fields.push_array(self.encrypted_logs_hash); fields.push_array(self.unencrypted_logs_hash); fields.push(self.encrypted_log_preimages_length); @@ -239,12 +312,13 @@ impl PrivateCircuitPublicInputs { fields.push_array(self.call_context.serialize()); fields.push(self.args_hash); fields.push_array(self.return_values); - fields.push_array(self.read_requests); - fields.push_array(self.new_commitments); - fields.push_array(self.new_nullifiers); - fields.push_array(self.private_call_stack); - fields.push_array(self.public_call_stack); - fields.push_array(self.new_l2_to_l1_msgs); + fields.flatten_and_push_array(SideEffect::serialize, self.read_requests); + fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments); + fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers); + // TODO(dbanks12): should nullified commitments be here! + fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack); + fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack); + fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs); fields.push_array(self.encrypted_logs_hash); fields.push_array(self.unencrypted_logs_hash); fields.push(self.encrypted_log_preimages_length); @@ -260,19 +334,21 @@ impl PrivateCircuitPublicInputs { struct ContractStorageRead { storage_slot: Field, value: Field, + side_effect_counter: Field, } impl ContractStorageRead { fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] { - [self.storage_slot, self.value] + [self.storage_slot, self.value, self.side_effect_counter] } fn hash(self) -> Field { + // TODO(dbanks12): do we include side-effect counter in hash? dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0] } fn empty() -> Self { - Self { storage_slot: 0, value: 0 } + Self { storage_slot: 0, value: 0, side_effect_counter: 0 } } } @@ -280,19 +356,21 @@ struct ContractStorageUpdateRequest { storage_slot: Field, old_value: Field, new_value: Field, + side_effect_counter: Field, } impl ContractStorageUpdateRequest { fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] { - [self.storage_slot, self.old_value, self.new_value] + [self.storage_slot, self.old_value, self.new_value, self.side_effect_counter] } fn hash(self) -> Field { + // TODO(dbanks12): do we include side-effect counter in hash? dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0] } fn empty() -> Self { - Self { storage_slot: 0, old_value: 0, new_value: 0 } + Self { storage_slot: 0, old_value: 0, new_value: 0, side_effect_counter: 0 } } } @@ -303,10 +381,10 @@ struct PublicCircuitPublicInputs { return_values: [Field; RETURN_VALUES_LENGTH], contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL], contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL], - public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], - new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL], - new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL], - new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL], + public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], + new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL], + new_nullifiers: [SideEffectLinkedToNoteHash; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL], + new_l2_to_l1_msgs: [SideEffect; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL], unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256], unencrypted_log_preimages_length: Field, block_data: HistoricBlockData, @@ -317,7 +395,7 @@ struct PublicCircuitPublicInputs { } impl PublicCircuitPublicInputs { - + fn hash(self) -> Field { let mut inputs: BoundedVec = BoundedVec::new(0); inputs.push(self.call_context.hash()); @@ -329,10 +407,22 @@ impl PublicCircuitPublicInputs { for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL { inputs.push(self.contract_storage_read[i].hash()); } - inputs.push_array(self.public_call_stack); - inputs.push_array(self.new_commitments); - inputs.push_array(self.new_nullifiers); - inputs.push_array(self.new_l2_to_l1_msgs); + inputs.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack); + //for i in 0..MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL { + // inputs.push(self.public_call_stack[i].hash()); + //} + inputs.flatten_and_push_array(SideEffect::serialize, self.new_commitments); + //for i in 0..MAX_NEW_COMMITMENTS_PER_CALL { + // inputs.push(self.new_commitments[i].hash()); + //} + inputs.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers); + //for i in 0..MAX_NEW_NULLIFIERS_PER_CALL { + // inputs.push(self.new_nullifiers[i].hash()); + //} + inputs.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs); + //for i in 0..MAX_NEW_L2_TO_L1_MSGS_PER_CALL { + // inputs.push(self.new_l2_to_l1_msgs[i].hash()); + //} // We do not include block_data since it's not in the cpp hash @@ -349,16 +439,12 @@ impl PublicCircuitPublicInputs { fields.push_array(self.call_context.serialize()); fields.push(self.args_hash); fields.push_array(self.return_values); - for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL { - fields.push_array(self.contract_storage_update_requests[i].serialize()); - } - for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL { - fields.push_array(self.contract_storage_read[i].serialize()); - } - fields.push_array(self.public_call_stack); - fields.push_array(self.new_commitments); - fields.push_array(self.new_nullifiers); - fields.push_array(self.new_l2_to_l1_msgs); + fields.flatten_and_push_array(ContractStorageUpdateRequest::serialize, self.contract_storage_update_requests); + fields.flatten_and_push_array(ContractStorageRead::serialize, self.contract_storage_read); + fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack); + fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments); + fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers); + fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs); fields.push_array(self.unencrypted_logs_hash); fields.push(self.unencrypted_log_preimages_length); fields.push_array(self.block_data.serialize()); diff --git a/yarn-project/aztec-nr/aztec/src/context.nr b/yarn-project/aztec-nr/aztec/src/context.nr index 022319561cb6..9705b8dc6427 100644 --- a/yarn-project/aztec-nr/aztec/src/context.nr +++ b/yarn-project/aztec-nr/aztec/src/context.nr @@ -22,6 +22,9 @@ use crate::abi::{ FunctionData, PrivateCircuitPublicInputs, PublicCircuitPublicInputs, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, }; // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) @@ -53,19 +56,19 @@ use dep::std::option::Option; struct PrivateContext { // docs:start:private-context inputs: abi::PrivateContextInputs, + side_effect_counter: Field, args_hash : Field, return_values : BoundedVec, - read_requests: BoundedVec, + read_requests: BoundedVec, - new_commitments: BoundedVec, - new_nullifiers: BoundedVec, - nullified_commitments: BoundedVec, + new_commitments: BoundedVec, + new_nullifiers: BoundedVec, - private_call_stack : BoundedVec, - public_call_stack : BoundedVec, - new_l2_to_l1_msgs : BoundedVec, + private_call_stack : BoundedVec, + public_call_stack : BoundedVec, + new_l2_to_l1_msgs : BoundedVec, // docs:end:private-context block_data: HistoricBlockData, @@ -79,21 +82,26 @@ impl PrivateContext { fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext { PrivateContext { inputs: inputs, + // starts at 1 because all private calls have txhash nullifier as 0th nullifier + // and therefore 0th sideeffect + // increments for each side effect in this context + side_effect_counter: 1, args_hash: args_hash, return_values: BoundedVec::new(0), - read_requests: BoundedVec::new(0), + read_requests: BoundedVec::new(SideEffect::empty()), - new_commitments: BoundedVec::new(0), - new_nullifiers: BoundedVec::new(0), + new_commitments: BoundedVec::new(SideEffect::empty()), + new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()), + // TODO(dbanks12): remove me! nullified_commitments: BoundedVec::new(0), block_data: inputs.block_data, - private_call_stack: BoundedVec::new(0), - public_call_stack: BoundedVec::new(0), - new_l2_to_l1_msgs: BoundedVec::new(0), + private_call_stack: BoundedVec::new(SideEffectWithRange::empty()), + public_call_stack: BoundedVec::new(SideEffectWithRange::empty()), + new_l2_to_l1_msgs: BoundedVec::new(SideEffect::empty()), // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) // encrypted_logs_preimages: Vec::new(), @@ -135,6 +143,7 @@ impl PrivateContext { read_requests: self.read_requests.storage, new_commitments: self.new_commitments.storage, new_nullifiers: self.new_nullifiers.storage, + // TODO(dbanks12): remove me! nullified_commitments: self.nullified_commitments.storage, private_call_stack: self.private_call_stack.storage, public_call_stack: self.public_call_stack.storage, @@ -152,15 +161,32 @@ impl PrivateContext { } fn push_read_request(&mut self, read_request: Field) { - self.read_requests.push(read_request); + let side_effect = SideEffect { + value: read_request, + side_effect_counter: self.side_effect_counter + }; + self.read_requests.push(side_effect); + self.side_effect_counter++; } fn push_new_note_hash(&mut self, note_hash: Field) { - self.new_commitments.push(note_hash); + let side_effect = SideEffect { + value: note_hash, + side_effect_counter: self.side_effect_counter + }; + self.new_commitments.push(side_effect); + self.side_effect_counter++; } fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) { - self.new_nullifiers.push(nullifier); + let side_effect = SideEffectLinkedToNoteHash { + value: nullifier, + note_hash: nullified_commitment, + side_effect_counter: self.side_effect_counter + }; + self.new_nullifiers.push(side_effect); + self.side_effect_counter++; + // TODO(dbanks12): remove me! self.nullified_commitments.push(nullified_commitment); } @@ -168,7 +194,12 @@ impl PrivateContext { fn message_portal(&mut self, content: Field) // docs:end:context_message_portal { - self.new_l2_to_l1_msgs.push(content); + let side_effect = SideEffect { + value: content, + side_effect_counter: self.side_effect_counter + }; + self.new_l2_to_l1_msgs.push(side_effect); + self.side_effect_counter++; } // PrivateContextInputs must be temporarily passed in to prevent too many unknowns @@ -249,6 +280,8 @@ impl PrivateContext { is_delegate_call : fields[8] as bool, is_static_call : fields[9] as bool, is_contract_deployment: fields[10] as bool, + + start_side_effect_counter: fields[11] as bool, }, // TODO handle the offsets as a variable incremented during extraction? args_hash: fields[11], @@ -303,7 +336,13 @@ impl PrivateContext { assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address); assert(item.public_inputs.call_context.storage_contract_address == contract_address); - self.private_call_stack.push(item.hash()); + let side_effect = SideEffectWithRange { + value: item.hash(), + start_side_effect_counter: self.inputs.side_effect_counter, + end_side_effect_counter: self.side_effect_counter, + }; + self.private_call_stack.push(side_effect); + self.side_effect_counter++; item.public_inputs.return_values } @@ -355,15 +394,17 @@ impl PrivateContext { is_delegate_call : fields[8] as bool, is_static_call : fields[9] as bool, is_contract_deployment: fields[10] as bool, + + start_side_effect_counter: fields[11] as bool, }, - args_hash: fields[11], + args_hash: fields[12], return_values: [0; RETURN_VALUES_LENGTH], contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL], contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL], - public_call_stack: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], - new_commitments: [0; MAX_NEW_COMMITMENTS_PER_CALL], - new_nullifiers: [0; MAX_NEW_NULLIFIERS_PER_CALL], - new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], + public_call_stack: [SideEffectWithRange::empty(); MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], + new_commitments: [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL], + new_nullifiers: [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL], + new_l2_to_l1_msgs:[SideEffect::empty(); MAX_NEW_L2_TO_L1_MSGS_PER_CALL], unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256], unencrypted_log_preimages_length: 0, block_data: HistoricBlockData::empty(), @@ -387,7 +428,13 @@ impl PrivateContext { assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address); assert(item.public_inputs.call_context.storage_contract_address == contract_address); - self.public_call_stack.push(item.hash()); + let side_effect = SideEffectWithRange { + value: item.hash(), + start_side_effect_counter: self.inputs.side_effect_counter, + end_side_effect_counter: self.side_effect_counter, + }; + self.public_call_stack.push(side_effect); + self.private_call_stack.push(side_effect); } } @@ -404,12 +451,12 @@ struct PublicContext { contract_storage_update_requests: BoundedVec, contract_storage_read: BoundedVec, - public_call_stack: BoundedVec, + public_call_stack: BoundedVec, - new_commitments: BoundedVec, - new_nullifiers: BoundedVec, + new_commitments: BoundedVec, + new_nullifiers: BoundedVec, - new_l2_to_l1_msgs: BoundedVec, + new_l2_to_l1_msgs: BoundedVec, unencrypted_logs_hash: BoundedVec, unencrypted_logs_preimages_length: Field, @@ -425,19 +472,20 @@ impl PublicContext { PublicContext { inputs: inputs, + side_effect_counter: 0, // incremented for every side effect in this context + args_hash: args_hash, return_values: BoundedVec::new(0), contract_storage_update_requests: BoundedVec::new(empty_storage_update), contract_storage_read: BoundedVec::new(empty_storage_read), - public_call_stack: BoundedVec::new(0), + public_call_stack: BoundedVec::new(SideEffectWithRange::empty()), - new_commitments: BoundedVec::new(0), - new_nullifiers: BoundedVec::new(0), + new_commitments: BoundedVec::new(SideEffect::empty()), + new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()), - new_l2_to_l1_msgs: BoundedVec::new(0), + new_l2_to_l1_msgs: BoundedVec::new(SideEffect::empty()), - unencrypted_logs_hash: BoundedVec::new(0), unencrypted_logs_preimages_length: 0, @@ -485,6 +533,7 @@ impl PublicContext { // Compute the public call stack hashes + // TODO(dbanks12): is this actually computing any public call stack hashes as comment says? let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs { call_context: self.inputs.call_context, // Done args_hash: self.args_hash, // Done @@ -504,15 +553,31 @@ impl PublicContext { } fn push_new_note_hash(&mut self, note_hash: Field) { - self.new_commitments.push(note_hash); + let side_effect = SideEffect { + value: note_hash, + side_effect_counter: self.side_effect_counter + }; + self.new_commitments.push(side_effect); + self.side_effect_counter++; } fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) { - self.new_nullifiers.push(nullifier); + let side_effect = SideEffectLinkedToNoteHash { + value: nullifier, + note_hash: EMPTY_NULLIFIED_COMMITMENT, // cannot nullify pending notes in public context + side_effect_counter: self.side_effect_counter + }; + self.new_nullifiers.push(side_effect); + self.side_effect_counter++; } fn message_portal(&mut self, content: Field) { - self.new_l2_to_l1_msgs.push(content); + let side_effect = SideEffect { + value: content, + side_effect_counter: self.side_effect_counter + }; + self.new_l2_to_l1_msgs.push(side_effect); + self.side_effect_counter++; } // PrivateContextInputs must be temporarily passed in to prevent too many unknowns diff --git a/yarn-project/circuits.js/src/cbind/circuits.gen.ts b/yarn-project/circuits.js/src/cbind/circuits.gen.ts index 5dabbdef88f6..cc8b7726b00d 100644 --- a/yarn-project/circuits.js/src/cbind/circuits.gen.ts +++ b/yarn-project/circuits.js/src/cbind/circuits.gen.ts @@ -199,6 +199,114 @@ export function fromNativeAggregationState(o: NativeAggregationState): MsgpackNa }; } +interface MsgpackSideEffect { + value: Buffer; + side_effect_counter: Buffer; +} + +export function toSideEffect(o: MsgpackSideEffect): SideEffect { + if (o.value === undefined) { + throw new Error('Expected value in SideEffect deserialization'); + } + if (o.side_effect_counter === undefined) { + throw new Error('Expected side_effect_counter in SideEffect deserialization'); + } + return new SideEffect(Fr.fromBuffer(o.value), Fr.fromBuffer(o.side_effect_counter)); +} + +export function fromSideEffect(o: SideEffect): MsgpackSideEffect { + if (o.value === undefined) { + throw new Error('Expected value in SideEffect serialization'); + } + if (o.sideEffectCounter === undefined) { + throw new Error('Expected sideEffectCounter in SideEffect serialization'); + } + return { + value: toBuffer(o.value), + side_effect_counter: toBuffer(o.sideEffectCounter), + }; +} + +interface MsgpackSideEffectLinkedToNoteHash { + value: Buffer; + note_hash: Buffer; + side_effect_counter: Buffer; +} + +export function toSideEffectLinkedToNoteHash(o: MsgpackSideEffectLinkedToNoteHash): SideEffectLinkedToNoteHash { + if (o.value === undefined) { + throw new Error('Expected value in SideEffectLinkedToNoteHash deserialization'); + } + if (o.note_hash === undefined) { + throw new Error('Expected note_hash in SideEffectLinkedToNoteHash deserialization'); + } + if (o.side_effect_counter === undefined) { + throw new Error('Expected side_effect_counter in SideEffectLinkedToNoteHash deserialization'); + } + return new SideEffectLinkedToNoteHash( + Fr.fromBuffer(o.value), + Fr.fromBuffer(o.note_hash), + Fr.fromBuffer(o.side_effect_counter), + ); +} + +export function fromSideEffectLinkedToNoteHash(o: SideEffectLinkedToNoteHash): MsgpackSideEffectLinkedToNoteHash { + if (o.value === undefined) { + throw new Error('Expected value in SideEffectLinkedToNoteHash serialization'); + } + if (o.noteHash === undefined) { + throw new Error('Expected noteHash in SideEffectLinkedToNoteHash serialization'); + } + if (o.sideEffectCounter === undefined) { + throw new Error('Expected sideEffectCounter in SideEffectLinkedToNoteHash serialization'); + } + return { + value: toBuffer(o.value), + note_hash: toBuffer(o.noteHash), + side_effect_counter: toBuffer(o.sideEffectCounter), + }; +} + +interface MsgpackSideEffectWithRange { + value: Buffer; + start_side_effect_counter: Buffer; + end_side_effect_counter: Buffer; +} + +export function toSideEffectWithRange(o: MsgpackSideEffectWithRange): SideEffectWithRange { + if (o.value === undefined) { + throw new Error('Expected value in SideEffectWithRange deserialization'); + } + if (o.start_side_effect_counter === undefined) { + throw new Error('Expected start_side_effect_counter in SideEffectWithRange deserialization'); + } + if (o.end_side_effect_counter === undefined) { + throw new Error('Expected end_side_effect_counter in SideEffectWithRange deserialization'); + } + return new SideEffectWithRange( + Fr.fromBuffer(o.value), + Fr.fromBuffer(o.start_side_effect_counter), + Fr.fromBuffer(o.end_side_effect_counter), + ); +} + +export function fromSideEffectWithRange(o: SideEffectWithRange): MsgpackSideEffectWithRange { + if (o.value === undefined) { + throw new Error('Expected value in SideEffectWithRange serialization'); + } + if (o.startSideEffectCounter === undefined) { + throw new Error('Expected startSideEffectCounter in SideEffectWithRange serialization'); + } + if (o.endSideEffectCounter === undefined) { + throw new Error('Expected endSideEffectCounter in SideEffectWithRange serialization'); + } + return { + value: toBuffer(o.value), + start_side_effect_counter: toBuffer(o.startSideEffectCounter), + end_side_effect_counter: toBuffer(o.endSideEffectCounter), + }; +} + interface MsgpackNewContractData { contract_address: Buffer; portal_contract_address: Buffer; @@ -526,13 +634,13 @@ export function toCombinedAccumulatedData(o: MsgpackCombinedAccumulatedData): Co } return new CombinedAccumulatedData( toNativeAggregationState(o.aggregation_object), - mapTuple(o.read_requests, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_nullifiers, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.read_requests, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_commitments, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_nullifiers, (v: MsgpackSideEffectLinkedToNoteHash) => toSideEffectLinkedToNoteHash(v)), mapTuple(o.nullified_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.private_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.public_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_l2_to_l1_msgs, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.private_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.public_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.new_l2_to_l1_msgs, (v: MsgpackSideEffect) => toSideEffect(v)), mapTuple(o.encrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), mapTuple(o.unencrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), Fr.fromBuffer(o.encrypted_log_preimages_length), @@ -595,13 +703,13 @@ export function fromCombinedAccumulatedData(o: CombinedAccumulatedData): Msgpack } return { aggregation_object: fromNativeAggregationState(o.aggregationObject), - read_requests: mapTuple(o.readRequests, (v: Fr) => toBuffer(v)), - new_commitments: mapTuple(o.newCommitments, (v: Fr) => toBuffer(v)), - new_nullifiers: mapTuple(o.newNullifiers, (v: Fr) => toBuffer(v)), + read_requests: mapTuple(o.readRequests, (v: SideEffect) => fromSideEffect(v)), + new_commitments: mapTuple(o.newCommitments, (v: SideEffect) => fromSideEffect(v)), + new_nullifiers: mapTuple(o.newNullifiers, (v: SideEffectLinkedToNoteHash) => fromSideEffectLinkedToNoteHash(v)), nullified_commitments: mapTuple(o.nullifiedCommitments, (v: Fr) => toBuffer(v)), - private_call_stack: mapTuple(o.privateCallStack, (v: Fr) => toBuffer(v)), - public_call_stack: mapTuple(o.publicCallStack, (v: Fr) => toBuffer(v)), - new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: Fr) => toBuffer(v)), + private_call_stack: mapTuple(o.privateCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + public_call_stack: mapTuple(o.publicCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: SideEffect) => fromSideEffect(v)), encrypted_logs_hash: mapTuple(o.encryptedLogsHash, (v: Fr) => toBuffer(v)), unencrypted_logs_hash: mapTuple(o.unencryptedLogsHash, (v: Fr) => toBuffer(v)), encrypted_log_preimages_length: toBuffer(o.encryptedLogPreimagesLength), @@ -1244,13 +1352,13 @@ export function toPrivateCircuitPublicInputs(o: MsgpackPrivateCircuitPublicInput toCallContext(o.call_context), Fr.fromBuffer(o.args_hash), mapTuple(o.return_values, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.read_requests, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_nullifiers, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.read_requests, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_commitments, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_nullifiers, (v: MsgpackSideEffectLinkedToNoteHash) => toSideEffectLinkedToNoteHash(v)), mapTuple(o.nullified_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.private_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.public_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_l2_to_l1_msgs, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.private_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.public_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.new_l2_to_l1_msgs, (v: MsgpackSideEffect) => toSideEffect(v)), mapTuple(o.encrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), mapTuple(o.unencrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), Fr.fromBuffer(o.encrypted_log_preimages_length), @@ -1321,13 +1429,13 @@ export function fromPrivateCircuitPublicInputs(o: PrivateCircuitPublicInputs): M call_context: fromCallContext(o.callContext), args_hash: toBuffer(o.argsHash), return_values: mapTuple(o.returnValues, (v: Fr) => toBuffer(v)), - read_requests: mapTuple(o.readRequests, (v: Fr) => toBuffer(v)), - new_commitments: mapTuple(o.newCommitments, (v: Fr) => toBuffer(v)), - new_nullifiers: mapTuple(o.newNullifiers, (v: Fr) => toBuffer(v)), + read_requests: mapTuple(o.readRequests, (v: SideEffect) => fromSideEffect(v)), + new_commitments: mapTuple(o.newCommitments, (v: SideEffect) => fromSideEffect(v)), + new_nullifiers: mapTuple(o.newNullifiers, (v: SideEffectLinkedToNoteHash) => fromSideEffectLinkedToNoteHash(v)), nullified_commitments: mapTuple(o.nullifiedCommitments, (v: Fr) => toBuffer(v)), - private_call_stack: mapTuple(o.privateCallStack, (v: Fr) => toBuffer(v)), - public_call_stack: mapTuple(o.publicCallStack, (v: Fr) => toBuffer(v)), - new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: Fr) => toBuffer(v)), + private_call_stack: mapTuple(o.privateCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + public_call_stack: mapTuple(o.publicCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: SideEffect) => fromSideEffect(v)), encrypted_logs_hash: mapTuple(o.encryptedLogsHash, (v: Fr) => toBuffer(v)), unencrypted_logs_hash: mapTuple(o.unencryptedLogsHash, (v: Fr) => toBuffer(v)), encrypted_log_preimages_length: toBuffer(o.encryptedLogPreimagesLength), @@ -1781,12 +1889,12 @@ export function toFinalAccumulatedData(o: MsgpackFinalAccumulatedData): FinalAcc } return new FinalAccumulatedData( toNativeAggregationState(o.aggregation_object), - mapTuple(o.new_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_nullifiers, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.new_commitments, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_nullifiers, (v: MsgpackSideEffectLinkedToNoteHash) => toSideEffectLinkedToNoteHash(v)), mapTuple(o.nullified_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.private_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.public_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_l2_to_l1_msgs, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.private_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.public_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.new_l2_to_l1_msgs, (v: MsgpackSideEffect) => toSideEffect(v)), mapTuple(o.encrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), mapTuple(o.unencrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), Fr.fromBuffer(o.encrypted_log_preimages_length), @@ -1838,12 +1946,12 @@ export function fromFinalAccumulatedData(o: FinalAccumulatedData): MsgpackFinalA } return { aggregation_object: fromNativeAggregationState(o.aggregationObject), - new_commitments: mapTuple(o.newCommitments, (v: Fr) => toBuffer(v)), - new_nullifiers: mapTuple(o.newNullifiers, (v: Fr) => toBuffer(v)), + new_commitments: mapTuple(o.newCommitments, (v: SideEffect) => fromSideEffect(v)), + new_nullifiers: mapTuple(o.newNullifiers, (v: SideEffectLinkedToNoteHash) => fromSideEffectLinkedToNoteHash(v)), nullified_commitments: mapTuple(o.nullifiedCommitments, (v: Fr) => toBuffer(v)), - private_call_stack: mapTuple(o.privateCallStack, (v: Fr) => toBuffer(v)), - public_call_stack: mapTuple(o.publicCallStack, (v: Fr) => toBuffer(v)), - new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: Fr) => toBuffer(v)), + private_call_stack: mapTuple(o.privateCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + public_call_stack: mapTuple(o.publicCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: SideEffect) => fromSideEffect(v)), encrypted_logs_hash: mapTuple(o.encryptedLogsHash, (v: Fr) => toBuffer(v)), unencrypted_logs_hash: mapTuple(o.unencryptedLogsHash, (v: Fr) => toBuffer(v)), encrypted_log_preimages_length: toBuffer(o.encryptedLogPreimagesLength), @@ -2031,10 +2139,10 @@ export function toPublicCircuitPublicInputs(o: MsgpackPublicCircuitPublicInputs) toContractStorageUpdateRequest(v), ), mapTuple(o.contract_storage_reads, (v: MsgpackContractStorageRead) => toContractStorageRead(v)), - mapTuple(o.public_call_stack, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_commitments, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_nullifiers, (v: Buffer) => Fr.fromBuffer(v)), - mapTuple(o.new_l2_to_l1_msgs, (v: Buffer) => Fr.fromBuffer(v)), + mapTuple(o.public_call_stack, (v: MsgpackSideEffectWithRange) => toSideEffectWithRange(v)), + mapTuple(o.new_commitments, (v: MsgpackSideEffect) => toSideEffect(v)), + mapTuple(o.new_nullifiers, (v: MsgpackSideEffectLinkedToNoteHash) => toSideEffectLinkedToNoteHash(v)), + mapTuple(o.new_l2_to_l1_msgs, (v: MsgpackSideEffect) => toSideEffect(v)), mapTuple(o.unencrypted_logs_hash, (v: Buffer) => Fr.fromBuffer(v)), Fr.fromBuffer(o.unencrypted_log_preimages_length), toHistoricBlockData(o.historic_block_data), @@ -2090,10 +2198,10 @@ export function fromPublicCircuitPublicInputs(o: PublicCircuitPublicInputs): Msg fromContractStorageUpdateRequest(v), ), contract_storage_reads: mapTuple(o.contractStorageReads, (v: ContractStorageRead) => fromContractStorageRead(v)), - public_call_stack: mapTuple(o.publicCallStack, (v: Fr) => toBuffer(v)), - new_commitments: mapTuple(o.newCommitments, (v: Fr) => toBuffer(v)), - new_nullifiers: mapTuple(o.newNullifiers, (v: Fr) => toBuffer(v)), - new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: Fr) => toBuffer(v)), + public_call_stack: mapTuple(o.publicCallStack, (v: SideEffectWithRange) => fromSideEffectWithRange(v)), + new_commitments: mapTuple(o.newCommitments, (v: SideEffect) => fromSideEffect(v)), + new_nullifiers: mapTuple(o.newNullifiers, (v: SideEffectLinkedToNoteHash) => fromSideEffectLinkedToNoteHash(v)), + new_l2_to_l1_msgs: mapTuple(o.newL2ToL1Msgs, (v: SideEffect) => fromSideEffect(v)), unencrypted_logs_hash: mapTuple(o.unencryptedLogsHash, (v: Fr) => toBuffer(v)), unencrypted_log_preimages_length: toBuffer(o.unencryptedLogPreimagesLength), historic_block_data: fromHistoricBlockData(o.historicBlockData), diff --git a/yarn-project/circuits.js/src/cbind/types.ts b/yarn-project/circuits.js/src/cbind/types.ts index 5c2d7c9f8b57..077abe04397a 100644 --- a/yarn-project/circuits.js/src/cbind/types.ts +++ b/yarn-project/circuits.js/src/cbind/types.ts @@ -126,6 +126,9 @@ export { MergeRollupInputs, RootRollupInputs, RootRollupPublicInputs, + SideEffect, + SideEffectWithRange, + SideEffectLinkedToNoteHash, } from '../structs/index.js'; export { FunctionSelector } from '@aztec/foundation/abi'; diff --git a/yarn-project/circuits.js/src/kernel/public_kernel.test.ts b/yarn-project/circuits.js/src/kernel/public_kernel.test.ts index c8b28c2daa79..901ea8454b8a 100644 --- a/yarn-project/circuits.js/src/kernel/public_kernel.test.ts +++ b/yarn-project/circuits.js/src/kernel/public_kernel.test.ts @@ -4,6 +4,7 @@ import { MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, MAX_PUBLIC_DATA_READS_PER_CALL, MAX_PUBLIC_DATA_READS_PER_TX, + SideEffectWithRange, makeTuple, simulatePublicKernelCircuit, } from '../index.js'; @@ -23,7 +24,10 @@ describe('kernel/public_kernel', () => { it('simulates public kernel circuit with previous private kernel', async function () { const input = await makePublicKernelInputsWithTweak(1, input => { input.previousKernel.publicInputs.isPrivate = true; - input.previousKernel.publicInputs.end.privateCallStack = makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, Fr.zero); + input.previousKernel.publicInputs.end.privateCallStack = makeTuple( + MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, + SideEffectWithRange.empty, + ); }); const result = await simulatePublicKernelCircuit(input); expect(result).toBeDefined(); diff --git a/yarn-project/circuits.js/src/structs/index.ts b/yarn-project/circuits.js/src/structs/index.ts index 7e31d2957b4b..796c73b15215 100644 --- a/yarn-project/circuits.js/src/structs/index.ts +++ b/yarn-project/circuits.js/src/structs/index.ts @@ -30,6 +30,7 @@ export * from './membership_witness.js'; export * from './read_request_membership_witness.js'; export * from './public_call_request.js'; export * from '@aztec/foundation/eth-address'; +export * from './side_effects.js'; export * from '@aztec/foundation/fields'; export * from '@aztec/foundation/aztec-address'; diff --git a/yarn-project/circuits.js/src/structs/kernel/combined_accumulated_data.ts b/yarn-project/circuits.js/src/structs/kernel/combined_accumulated_data.ts index 507aa13d8689..76d32bee41dd 100644 --- a/yarn-project/circuits.js/src/structs/kernel/combined_accumulated_data.ts +++ b/yarn-project/circuits.js/src/structs/kernel/combined_accumulated_data.ts @@ -16,7 +16,16 @@ import { } from '../../cbind/constants.gen.js'; import { makeTuple } from '../../index.js'; import { serializeToBuffer } from '../../utils/serialize.js'; -import { AggregationObject, AztecAddress, EthAddress, Fr, FunctionData } from '../index.js'; +import { + AggregationObject, + AztecAddress, + EthAddress, + Fr, + FunctionData, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, +} from '../index.js'; /** * The information assembled after the contract deployment was processed by the private kernel circuit. @@ -286,15 +295,15 @@ export class CombinedAccumulatedData { /** * All the read requests made in this transaction. */ - public readRequests: Tuple, + public readRequests: Tuple, /** * The new commitments made in this transaction. */ - public newCommitments: Tuple, + public newCommitments: Tuple, /** * The new nullifiers made in this transaction. */ - public newNullifiers: Tuple, + public newNullifiers: Tuple, /** * The commitments which are nullified by a nullifier in the above list. For pending nullifiers, we have: * nullifiedCommitments[j] != 0 if and only if newNullifiers[j] nullifies nullifiedCommitments[j] @@ -303,15 +312,15 @@ export class CombinedAccumulatedData { /** * Current private call stack. */ - public privateCallStack: Tuple, + public privateCallStack: Tuple, /** * Current public call stack. */ - public publicCallStack: Tuple, + public publicCallStack: Tuple, /** * All the new L2 to L1 messages created in this transaction. */ - public newL2ToL1Msgs: Tuple, + public newL2ToL1Msgs: Tuple, /** * Accumulated encrypted logs hash from all the previous kernel iterations. * Note: Represented as a tuple of 2 fields in order to fit in all of the 256 bits of sha256 hash. @@ -382,13 +391,13 @@ export class CombinedAccumulatedData { const reader = BufferReader.asReader(buffer); return new CombinedAccumulatedData( reader.readObject(AggregationObject), - reader.readArray(MAX_READ_REQUESTS_PER_TX, Fr), - reader.readArray(MAX_NEW_COMMITMENTS_PER_TX, Fr), - reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, Fr), + reader.readArray(MAX_READ_REQUESTS_PER_TX, SideEffect), + reader.readArray(MAX_NEW_COMMITMENTS_PER_TX, SideEffect), + reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, SideEffectLinkedToNoteHash), reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, Fr), - reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, Fr), - reader.readArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr), - reader.readArray(MAX_NEW_L2_TO_L1_MSGS_PER_TX, Fr), + reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange), + reader.readArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange), + reader.readArray(MAX_NEW_L2_TO_L1_MSGS_PER_TX, SideEffect), reader.readArray(2, Fr), reader.readArray(2, Fr), reader.readFr(), @@ -403,7 +412,7 @@ export class CombinedAccumulatedData { static fromFinalAccumulatedData(finalData: FinalAccumulatedData): CombinedAccumulatedData { return new CombinedAccumulatedData( finalData.aggregationObject, - makeTuple(MAX_READ_REQUESTS_PER_TX, Fr.zero), + makeTuple(MAX_READ_REQUESTS_PER_TX, SideEffect.empty), finalData.newCommitments, finalData.newNullifiers, finalData.nullifiedCommitments, @@ -433,13 +442,13 @@ export class CombinedAccumulatedData { static empty() { return new CombinedAccumulatedData( AggregationObject.makeFake(), - makeTuple(MAX_READ_REQUESTS_PER_TX, Fr.zero), - makeTuple(MAX_NEW_COMMITMENTS_PER_TX, Fr.zero), - makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero), + makeTuple(MAX_READ_REQUESTS_PER_TX, SideEffect.empty), + makeTuple(MAX_NEW_COMMITMENTS_PER_TX, SideEffect.empty), + makeTuple(MAX_NEW_NULLIFIERS_PER_TX, SideEffectLinkedToNoteHash.empty), makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero), - makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, Fr.zero), - makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr.zero), - makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, Fr.zero), + makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange.empty), + makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange.empty), + makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, SideEffect.empty), makeTuple(2, Fr.zero), makeTuple(2, Fr.zero), Fr.zero(), @@ -465,11 +474,11 @@ export class FinalAccumulatedData { /** * The new commitments made in this transaction. */ - public newCommitments: Tuple, + public newCommitments: Tuple, /** * The new nullifiers made in this transaction. */ - public newNullifiers: Tuple, + public newNullifiers: Tuple, /** * The commitments which are nullified by a nullifier in the above list. For pending nullifiers, we have: * nullifiedCommitments[j] != 0 if and only if newNullifiers[j] nullifies nullifiedCommitments[j] @@ -478,15 +487,15 @@ export class FinalAccumulatedData { /** * Current private call stack. */ - public privateCallStack: Tuple, + public privateCallStack: Tuple, /** * Current public call stack. */ - public publicCallStack: Tuple, + public publicCallStack: Tuple, /** * All the new L2 to L1 messages created in this transaction. */ - public newL2ToL1Msgs: Tuple, + public newL2ToL1Msgs: Tuple, /** * Accumulated encrypted logs hash from all the previous kernel iterations. * Note: Represented as a tuple of 2 fields in order to fit in all of the 256 bits of sha256 hash. @@ -546,12 +555,12 @@ export class FinalAccumulatedData { const reader = BufferReader.asReader(buffer); return new FinalAccumulatedData( reader.readObject(AggregationObject), - reader.readArray(MAX_NEW_COMMITMENTS_PER_TX, Fr), + reader.readArray(MAX_NEW_COMMITMENTS_PER_TX, SideEffect), + reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, SideEffectLinkedToNoteHash), reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, Fr), - reader.readArray(MAX_NEW_NULLIFIERS_PER_TX, Fr), - reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, Fr), - reader.readArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr), - reader.readArray(MAX_NEW_L2_TO_L1_MSGS_PER_TX, Fr), + reader.readArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange), + reader.readArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange), + reader.readArray(MAX_NEW_L2_TO_L1_MSGS_PER_TX, SideEffect), reader.readArray(2, Fr), reader.readArray(2, Fr), reader.readFr(), @@ -573,12 +582,12 @@ export class FinalAccumulatedData { static empty() { return new FinalAccumulatedData( AggregationObject.makeFake(), - makeTuple(MAX_NEW_COMMITMENTS_PER_TX, Fr.zero), - makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero), + makeTuple(MAX_NEW_COMMITMENTS_PER_TX, SideEffect.empty), + makeTuple(MAX_NEW_NULLIFIERS_PER_TX, SideEffectLinkedToNoteHash.empty), makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero), - makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, Fr.zero), - makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr.zero), - makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, Fr.zero), + makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange.empty), + makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange.empty), + makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, SideEffect.empty), makeTuple(2, Fr.zero), makeTuple(2, Fr.zero), Fr.zero(), diff --git a/yarn-project/circuits.js/src/structs/private_circuit_public_inputs.ts b/yarn-project/circuits.js/src/structs/private_circuit_public_inputs.ts index c89729ee4185..ab531c991f26 100644 --- a/yarn-project/circuits.js/src/structs/private_circuit_public_inputs.ts +++ b/yarn-project/circuits.js/src/structs/private_circuit_public_inputs.ts @@ -14,7 +14,7 @@ import { import { FieldsOf, makeTuple } from '../utils/jsUtils.js'; import { serializeToBuffer } from '../utils/serialize.js'; import { CallContext } from './call_context.js'; -import { HistoricBlockData } from './index.js'; +import { HistoricBlockData, SideEffect, SideEffectLinkedToNoteHash, SideEffectWithRange } from './index.js'; import { ContractDeploymentData } from './tx_context.js'; /** @@ -38,15 +38,15 @@ export class PrivateCircuitPublicInputs { /** * Read requests created by the corresponding function call. */ - public readRequests: Tuple, + public readRequests: Tuple, /** * New commitments created by the corresponding function call. */ - public newCommitments: Tuple, + public newCommitments: Tuple, /** * New nullifiers created by the corresponding function call. */ - public newNullifiers: Tuple, + public newNullifiers: Tuple, /** * The commitments those were nullified by the above newNullifiers. */ @@ -54,15 +54,15 @@ export class PrivateCircuitPublicInputs { /** * Private call stack at the current kernel iteration. */ - public privateCallStack: Tuple, + public privateCallStack: Tuple, /** * Public call stack at the current kernel iteration. */ - public publicCallStack: Tuple, + public publicCallStack: Tuple, /** * New L2 to L1 messages created by the corresponding function call. */ - public newL2ToL1Msgs: Tuple, + public newL2ToL1Msgs: Tuple, /** * Hash of the encrypted logs emitted in this function call. * Note: Represented as an array of 2 fields in order to fit in all of the 256 bits of sha256 hash. @@ -118,13 +118,13 @@ export class PrivateCircuitPublicInputs { CallContext.empty(), Fr.ZERO, makeTuple(RETURN_VALUES_LENGTH, Fr.zero), - makeTuple(MAX_READ_REQUESTS_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, Fr.zero), + makeTuple(MAX_READ_REQUESTS_PER_CALL, SideEffect.empty), + makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, SideEffect.empty), + makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, SideEffectLinkedToNoteHash.empty), makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, Fr.zero), - makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, Fr.zero), - makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, Fr.zero), + makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, SideEffectWithRange.empty), + makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, SideEffectWithRange.empty), + makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, SideEffect.empty), makeTuple(NUM_FIELDS_PER_SHA256, Fr.zero), makeTuple(NUM_FIELDS_PER_SHA256, Fr.zero), Fr.ZERO, diff --git a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts index 310323b15973..38bfa9610d00 100644 --- a/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts +++ b/yarn-project/circuits.js/src/structs/public_circuit_public_inputs.ts @@ -15,7 +15,7 @@ import { import { FieldsOf, makeTuple } from '../utils/jsUtils.js'; import { serializeToBuffer } from '../utils/serialize.js'; import { CallContext } from './call_context.js'; -import { HistoricBlockData } from './index.js'; +import { HistoricBlockData, SideEffect, SideEffectLinkedToNoteHash, SideEffectWithRange } from './index.js'; /** * Contract storage read operation on a specific contract. @@ -175,19 +175,19 @@ export class PublicCircuitPublicInputs { /** * Public call stack of the current kernel iteration. */ - public publicCallStack: Tuple, + public publicCallStack: Tuple, /** * New commitments created within a public execution call */ - public newCommitments: Tuple, + public newCommitments: Tuple, /** * New nullifiers created within a public execution call */ - public newNullifiers: Tuple, + public newNullifiers: Tuple, /** * New L2 to L1 messages generated during the call. */ - public newL2ToL1Msgs: Tuple, + public newL2ToL1Msgs: Tuple, /** * Hash of the unencrypted logs emitted in this function call. * Note: Represented as an array of 2 fields in order to fit in all of the 256 bits of sha256 hash. @@ -227,10 +227,10 @@ export class PublicCircuitPublicInputs { makeTuple(RETURN_VALUES_LENGTH, Fr.zero), makeTuple(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL, ContractStorageUpdateRequest.empty), makeTuple(MAX_PUBLIC_DATA_READS_PER_CALL, ContractStorageRead.empty), - makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, Fr.zero), - makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, Fr.zero), + makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, SideEffectWithRange.empty), + makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, SideEffect.empty), + makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, SideEffectLinkedToNoteHash.empty), + makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, SideEffect.empty), makeTuple(2, Fr.zero), Fr.ZERO, HistoricBlockData.empty(), @@ -240,16 +240,20 @@ export class PublicCircuitPublicInputs { isEmpty() { const isFrArrayEmpty = (arr: Fr[]) => isArrayEmpty(arr, item => item.isZero()); + const isSideEffectArrayEmpty = (arr: SideEffect[]) => isArrayEmpty(arr, item => item.isEmpty()); + const isSideEffectRangeArrayEmpty = (arr: SideEffectWithRange[]) => isArrayEmpty(arr, item => item.isEmpty()); + const isSideEffectLinkedArrayEmpty = (arr: SideEffectLinkedToNoteHash[]) => + isArrayEmpty(arr, item => item.isEmpty()); return ( this.callContext.isEmpty() && this.argsHash.isZero() && isFrArrayEmpty(this.returnValues) && isArrayEmpty(this.contractStorageUpdateRequests, item => item.isEmpty()) && isArrayEmpty(this.contractStorageReads, item => item.isEmpty()) && - isFrArrayEmpty(this.publicCallStack) && - isFrArrayEmpty(this.newCommitments) && - isFrArrayEmpty(this.newNullifiers) && - isFrArrayEmpty(this.newL2ToL1Msgs) && + isSideEffectRangeArrayEmpty(this.publicCallStack) && + isSideEffectArrayEmpty(this.newCommitments) && + isSideEffectLinkedArrayEmpty(this.newNullifiers) && + isSideEffectArrayEmpty(this.newL2ToL1Msgs) && isFrArrayEmpty(this.unencryptedLogsHash) && this.unencryptedLogPreimagesLength.isZero() && this.historicBlockData.isEmpty() && diff --git a/yarn-project/circuits.js/src/structs/side_effects.ts b/yarn-project/circuits.js/src/structs/side_effects.ts new file mode 100644 index 000000000000..ffa34422e1c7 --- /dev/null +++ b/yarn-project/circuits.js/src/structs/side_effects.ts @@ -0,0 +1,165 @@ +import { BufferReader } from '@aztec/foundation/serialize'; + +import { serializeToBuffer } from '../utils/serialize.js'; +import { Fr } from './index.js'; + +/** + * Side-effect object consisting of a value and a counter. + * cpp/src/aztec3/circuits/abis/side_effects.hpp. + */ +export class SideEffect { + constructor( + /** + * The value of the side-effect object. + */ + public value: Fr, + /** + * The side-effect counter. + */ + public sideEffectCounter: Fr, + ) {} + + /** + * Serialize this as a buffer. + * @returns The buffer. + */ + toBuffer(): Buffer { + return serializeToBuffer(this.value, this.sideEffectCounter); + } + + /** + * Returns whether this instance of side-effect is empty. + * @returns True if the value and counter both are zero. + */ + isEmpty() { + return this.value.isZero() && this.sideEffectCounter.isZero(); + } + + /** + * Returns an empty instance of side-effect. + * @returns Side-effect with both value and counter being zero. + */ + static empty(): SideEffect { + return new SideEffect(Fr.zero(), Fr.zero()); + } + + /** + * Deserializes from a buffer or reader, corresponding to a write in cpp. + * @param buffer - Buffer or reader to read from. + * @returns A new instance of SideEffect. + */ + static fromBuffer(buffer: Buffer | BufferReader): SideEffect { + const reader = BufferReader.asReader(buffer); + return new SideEffect(reader.readFr(), reader.readFr()); + } +} + +/** + * Side-effect object consisting of a value, a start counter and an end counter. + * cpp/src/aztec3/circuits/abis/side_effects.hpp. + */ +export class SideEffectWithRange { + constructor( + /** + * The value of the side-effect object. + */ + public value: Fr, + /** + * The start counter. + */ + public startSideEffectCounter: Fr, + /** + * The end counter. + */ + public endSideEffectCounter: Fr, + ) {} + + /** + * Serialize this as a buffer. + * @returns The buffer. + */ + toBuffer(): Buffer { + return serializeToBuffer(this.value, this.startSideEffectCounter, this.endSideEffectCounter); + } + + /** + * Returns whether this instance of side-effect is empty. + * @returns True if the value and both counters are zero. + */ + isEmpty() { + return this.value.isZero() && this.startSideEffectCounter.isZero() && this.endSideEffectCounter.isZero(); + } + + /** + * Returns an empty instance of side-effect. + * @returns Side-effect with value and counters being zero. + */ + static empty(): SideEffectWithRange { + return new SideEffectWithRange(Fr.zero(), Fr.zero(), Fr.zero()); + } + + /** + * Deserializes from a buffer or reader, corresponding to a write in cpp. + * @param buffer - Buffer or reader to read from. + * @returns A new instance of SideEffectWithRange. + */ + static fromBuffer(buffer: Buffer | BufferReader): SideEffectWithRange { + const reader = BufferReader.asReader(buffer); + return new SideEffectWithRange(reader.readFr(), reader.readFr(), reader.readFr()); + } +} + +/** + * Side-effect object consisting of a value, a start counter and an end counter. + * cpp/src/aztec3/circuits/abis/side_effects.hpp. + */ +export class SideEffectLinkedToNoteHash { + constructor( + /** + * The value of the side-effect object. + */ + public value: Fr, + /** + * The note hash corresponding to the side-effect value. + */ + public noteHash: Fr, + /** + * The counter. + */ + public sideEffectCounter: Fr, + ) {} + + /** + * Serialize this as a buffer. + * @returns The buffer. + */ + toBuffer(): Buffer { + return serializeToBuffer(this.value, this.noteHash, this.sideEffectCounter); + } + + /** + * Returns whether this instance of side-effect is empty. + * @returns True if the value, note hash and counter are all zero. + */ + isEmpty() { + return this.value.isZero() && this.noteHash.isZero() && this.sideEffectCounter.isZero(); + } + + /** + * Returns an empty instance of side-effect. + * @returns Side-effect with value, note hash and counter being zero. + */ + static empty(): SideEffectLinkedToNoteHash { + return new SideEffectLinkedToNoteHash(Fr.zero(), Fr.zero(), Fr.zero()); + } + + /** + * Deserializes from a buffer or reader, corresponding to a write in cpp. + * @param buffer - Buffer or reader to read from. + * @returns A new instance of SideEffectLinkedToNoteHash. + */ + static fromBuffer(buffer: Buffer | BufferReader): SideEffectLinkedToNoteHash { + const reader = BufferReader.asReader(buffer); + return new SideEffectLinkedToNoteHash(reader.readFr(), reader.readFr(), reader.readFr()); + } +} diff --git a/yarn-project/circuits.js/src/tests/factories.ts b/yarn-project/circuits.js/src/tests/factories.ts index 8f6a1cbb6014..6b404f699633 100644 --- a/yarn-project/circuits.js/src/tests/factories.ts +++ b/yarn-project/circuits.js/src/tests/factories.ts @@ -89,6 +89,9 @@ import { RollupTypes, RootRollupInputs, RootRollupPublicInputs, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, TxContext, TxRequest, VK_TREE_HEIGHT, @@ -210,13 +213,13 @@ export function makeAccumulatedData(seed = 1, full = false): CombinedAccumulated return new CombinedAccumulatedData( makeAggregationObject(seed), - tupleGenerator(MAX_READ_REQUESTS_PER_TX, fr, seed + 0x80), - tupleGenerator(MAX_NEW_COMMITMENTS_PER_TX, fr, seed + 0x100), - tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x200), + tupleGenerator(MAX_READ_REQUESTS_PER_TX, sideEffectFromNumber, seed + 0x80), + tupleGenerator(MAX_NEW_COMMITMENTS_PER_TX, sideEffectFromNumber, seed + 0x100), + tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, sideEffectLinkedFromNumber, seed + 0x200), tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x300), - tupleGenerator(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, fr, seed + 0x400), - tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, fr, seed + 0x500), - tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_TX, fr, seed + 0x600), + tupleGenerator(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, sideEffectRangeFromNumber, seed + 0x400), + tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, sideEffectRangeFromNumber, seed + 0x500), + tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_TX, sideEffectFromNumber, seed + 0x600), tupleGenerator(2, fr, seed + 0x700), // encrypted logs hash tupleGenerator(2, fr, seed + 0x800), // unencrypted logs hash fr(seed + 0x900), // encrypted_log_preimages_length @@ -238,12 +241,12 @@ export function makeFinalAccumulatedData(seed = 1, full = false): FinalAccumulat return new FinalAccumulatedData( makeAggregationObject(seed), - tupleGenerator(MAX_NEW_COMMITMENTS_PER_TX, fr, seed + 0x100), - tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x200), + tupleGenerator(MAX_NEW_COMMITMENTS_PER_TX, sideEffectFromNumber, seed + 0x100), + tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, sideEffectLinkedFromNumber, seed + 0x200), tupleGenerator(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x300), - tupleGenerator(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, fr, seed + 0x400), - tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, fr, seed + 0x500), - tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_TX, fr, seed + 0x600), + tupleGenerator(MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX, sideEffectRangeFromNumber, seed + 0x400), + tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, sideEffectRangeFromNumber, seed + 0x500), + tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_TX, sideEffectFromNumber, seed + 0x600), tupleGenerator(2, fr, seed + 0x700), // encrypted logs hash tupleGenerator(2, fr, seed + 0x800), // unencrypted logs hash fr(seed + 0x900), // encrypted_log_preimages_length @@ -323,10 +326,10 @@ export function makePublicCircuitPublicInputs( tupleGenerator(RETURN_VALUES_LENGTH, fr, seed + 0x200), tupleGenerator(MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL, makeContractStorageUpdateRequest, seed + 0x400), tupleGenerator(MAX_PUBLIC_DATA_READS_PER_CALL, makeContractStorageRead, seed + 0x500), - tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, fr, seed + 0x600), - tupleGenerator(MAX_NEW_COMMITMENTS_PER_CALL, fr, seed + 0x700), - tupleGenerator(MAX_NEW_NULLIFIERS_PER_CALL, fr, seed + 0x800), - tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, fr, seed + 0x900), + tupleGenerator(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, sideEffectRangeFromNumber, seed + 0x600), + tupleGenerator(MAX_NEW_COMMITMENTS_PER_CALL, sideEffectFromNumber, seed + 0x700), + tupleGenerator(MAX_NEW_NULLIFIERS_PER_CALL, sideEffectLinkedFromNumber, seed + 0x800), + tupleGenerator(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, sideEffectFromNumber, seed + 0x900), tupleGenerator(2, fr, seed + 0x901), fr(seed + 0x902), makeHistoricBlockData(seed + 0xa00), @@ -533,7 +536,7 @@ export async function makePublicCallData(seed = 1, full = false): Promise computeCallStackItemHash(wasm!, preimage), + preimage => new SideEffectWithRange(computeCallStackItemHash(wasm!, preimage), Fr.zero(), Fr.zero()), ); return publicCallData; @@ -582,7 +585,7 @@ export async function makePublicKernelInputsWithTweak( if (tweak) tweak(publicKernelInputs); // Set the call stack item for this circuit iteration at the top of the call stack const wasm = await CircuitsWasm.get(); - publicKernelInputs.previousKernel.publicInputs.end.publicCallStack[MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX - 1] = + publicKernelInputs.previousKernel.publicInputs.end.publicCallStack[MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX - 1].value = computeCallStackItemHash(wasm, publicKernelInputs.publicCall.callStackItem); return publicKernelInputs; } @@ -655,13 +658,13 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn ), argsHash: fr(seed + 0x100), returnValues: makeTuple(RETURN_VALUES_LENGTH, fr, seed + 0x200), - readRequests: makeTuple(MAX_READ_REQUESTS_PER_CALL, fr, seed + 0x300), - newCommitments: makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, fr, seed + 0x400), - newNullifiers: makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, fr, seed + 0x500), + readRequests: makeTuple(MAX_READ_REQUESTS_PER_CALL, sideEffectFromNumber, seed + 0x300), + newCommitments: makeTuple(MAX_NEW_COMMITMENTS_PER_CALL, sideEffectFromNumber, seed + 0x400), + newNullifiers: makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, sideEffectLinkedFromNumber, seed + 0x500), nullifiedCommitments: makeTuple(MAX_NEW_NULLIFIERS_PER_CALL, fr, seed + 0x510), - privateCallStack: makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, fr, seed + 0x600), - publicCallStack: makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, fr, seed + 0x700), - newL2ToL1Msgs: makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, fr, seed + 0x800), + privateCallStack: makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, sideEffectRangeFromNumber, seed + 0x600), + publicCallStack: makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL, sideEffectRangeFromNumber, seed + 0x700), + newL2ToL1Msgs: makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_CALL, sideEffectFromNumber, seed + 0x800), encryptedLogsHash: makeTuple(NUM_FIELDS_PER_SHA256, fr, seed + 0x900), unencryptedLogsHash: makeTuple(NUM_FIELDS_PER_SHA256, fr, seed + 0xa00), encryptedLogPreimagesLength: fr(seed + 0xb00), @@ -953,3 +956,30 @@ export function makeBaseRollupInputs(seed = 0): BaseRollupInputs { export function fr(n: number): Fr { return new Fr(BigInt(n)); } + +/** + * Test only. Easy to identify big endian side-effect serialize. + * @param n - The number. + * @returns The SideEffect instance. + */ +export function sideEffectFromNumber(n: number): SideEffect { + return new SideEffect(new Fr(BigInt(n)), Fr.zero()); +} + +/** + * Test only. Easy to identify big endian side-effect serialize. + * @param n - The number. + * @returns The SideEffect instance. + */ +export function sideEffectRangeFromNumber(n: number): SideEffectWithRange { + return new SideEffectWithRange(new Fr(BigInt(n)), Fr.zero(), Fr.zero()); +} + +/** + * Test only. Easy to identify big endian side-effect serialize. + * @param n - The number. + * @returns The SideEffect instance. + */ +export function sideEffectLinkedFromNumber(n: number): SideEffectLinkedToNoteHash { + return new SideEffectLinkedToNoteHash(new Fr(BigInt(n)), Fr.zero(), Fr.zero()); +} From b4812fa47c669a51462e74a13465bd004277dfdb Mon Sep 17 00:00:00 2001 From: Suyash Bagad Date: Wed, 13 Sep 2023 10:48:08 +0000 Subject: [PATCH 2/7] wip noir. fix. fix. fix noir issues. fix noir issues. update circuits.gen.ts Fix one more noir issue Fix one more noir issue fix but does not really fix my problem --- .../src/aztec3/circuits/abis/call_context.hpp | 29 +++++-- ...native_private_kernel_circuit_ordering.cpp | 2 +- circuits/cpp/src/aztec3/constants.hpp | 2 +- .../src/core/libraries/ConstantsGen.sol | 16 ++-- yarn-project/aztec-nr/aztec/src/abi.nr | 30 +++++++ .../aztec-nr/aztec/src/constants_gen.nr | 16 ++-- yarn-project/aztec-nr/aztec/src/context.nr | 87 ++++++++++--------- .../oracle/enqueue_public_function_call.nr | 4 +- .../aztec-nr/aztec/src/state_vars/set.nr | 7 +- yarn-project/aztec-nr/aztec/src/types/vec.nr | 14 +++ yarn-project/aztec-nr/aztec/src/utils.nr | 55 ++++++++++++ .../circuits.js/src/cbind/circuits.gen.ts | 54 +++++++----- .../circuits.js/src/cbind/constants.gen.ts | 16 ++-- .../circuits.js/src/structs/call_context.ts | 8 +- .../circuits.js/src/tests/factories.ts | 11 ++- 15 files changed, 250 insertions(+), 101 deletions(-) diff --git a/circuits/cpp/src/aztec3/circuits/abis/call_context.hpp b/circuits/cpp/src/aztec3/circuits/abis/call_context.hpp index 4a00d2a81754..4b9f8b61a6f1 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/call_context.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/call_context.hpp @@ -27,13 +27,16 @@ template struct CallContext { boolean is_static_call = false; boolean is_contract_deployment = false; + fr start_side_effect_counter = 0; + // for serialization, update with new fields MSGPACK_FIELDS(msg_sender, storage_contract_address, portal_contract_address, is_delegate_call, is_static_call, - is_contract_deployment); + is_contract_deployment, + start_side_effect_counter); boolean operator==(CallContext const& other) const { // we can't use =default with a custom boolean, but we can use a msgpack-derived utility @@ -48,8 +51,13 @@ template struct CallContext { auto to_ct = [&](auto& e) { return aztec3::utils::types::to_ct(builder, e); }; CallContext> call_context = { - to_ct(msg_sender), to_ct(storage_contract_address), to_ct(portal_contract_address), - to_ct(is_delegate_call), to_ct(is_static_call), to_ct(is_contract_deployment), + to_ct(msg_sender), + to_ct(storage_contract_address), + to_ct(portal_contract_address), + to_ct(is_delegate_call), + to_ct(is_static_call), + to_ct(is_contract_deployment), + to_ct(start_side_effect_counter), }; @@ -62,8 +70,13 @@ template struct CallContext { auto to_nt = [&](auto& e) { return aztec3::utils::types::to_nt(e); }; CallContext call_context = { - to_nt(msg_sender), to_nt(storage_contract_address), to_nt(portal_contract_address), - to_nt(is_delegate_call), to_nt(is_static_call), to_nt(is_contract_deployment), + to_nt(msg_sender), + to_nt(storage_contract_address), + to_nt(portal_contract_address), + to_nt(is_delegate_call), + to_nt(is_static_call), + to_nt(is_contract_deployment), + to_nt(start_side_effect_counter), }; return call_context; @@ -72,8 +85,8 @@ template struct CallContext { fr hash() const { std::vector const inputs = { - msg_sender.to_field(), storage_contract_address.to_field(), portal_contract_address, fr(is_delegate_call), - fr(is_static_call), fr(is_contract_deployment), + msg_sender.to_field(), storage_contract_address.to_field(), portal_contract_address, fr(is_delegate_call), + fr(is_static_call), fr(is_contract_deployment), start_side_effect_counter, }; return NCT::hash(inputs, GeneratorIndex::CALL_CONTEXT); @@ -89,6 +102,7 @@ template struct CallContext { fr(is_delegate_call).assert_is_zero(); fr(is_static_call).assert_is_zero(); fr(is_contract_deployment).assert_is_zero(); + start_side_effect_counter.assert_is_zero(); } void set_public() @@ -101,6 +115,7 @@ template struct CallContext { fr(is_delegate_call).set_public(); fr(is_static_call).set_public(); fr(is_contract_deployment).set_public(); + start_side_effect_counter.set_public(); } }; diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp index ee49da391782..0cec73a1d5d7 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/native_private_kernel_circuit_ordering.cpp @@ -112,7 +112,7 @@ void match_nullifiers_to_commitments_and_squash( size_t match_pos = MAX_NEW_COMMITMENTS_PER_TX; if (hint_pos < MAX_NEW_COMMITMENTS_PER_TX) { - match_pos = nullified_commitment == new_commitments[hint_pos] ? hint_pos : match_pos; + match_pos = nullified_commitment == new_commitments[hint_pos].value ? hint_pos : match_pos; } if (match_pos != MAX_NEW_COMMITMENTS_PER_TX) { diff --git a/circuits/cpp/src/aztec3/constants.hpp b/circuits/cpp/src/aztec3/constants.hpp index 8cac71d1729e..37f9a04d5b80 100644 --- a/circuits/cpp/src/aztec3/constants.hpp +++ b/circuits/cpp/src/aztec3/constants.hpp @@ -225,7 +225,7 @@ constexpr size_t MAX_NOTES_PER_PAGE = 10; // + 2 for EXTRA_DATA: [number_of_return_notes, contract_address] constexpr size_t VIEW_NOTE_ORACLE_RETURN_LENGTH = MAX_NOTES_PER_PAGE * (MAX_NOTE_FIELDS_LENGTH + 1) + 2; -constexpr size_t CALL_CONTEXT_LENGTH = 6; +constexpr size_t CALL_CONTEXT_LENGTH = 7; // Must be updated if any data is added into the block hash calculation. constexpr size_t HISTORIC_BLOCK_DATA_LENGTH = 7; constexpr size_t FUNCTION_DATA_LENGTH = 4; diff --git a/l1-contracts/src/core/libraries/ConstantsGen.sol b/l1-contracts/src/core/libraries/ConstantsGen.sol index f314fbf484c4..ad3f7278fc2e 100644 --- a/l1-contracts/src/core/libraries/ConstantsGen.sol +++ b/l1-contracts/src/core/libraries/ConstantsGen.sol @@ -67,19 +67,19 @@ library Constants { uint256 internal constant GET_NOTE_ORACLE_RETURN_LENGTH = 23; uint256 internal constant MAX_NOTES_PER_PAGE = 10; uint256 internal constant VIEW_NOTE_ORACLE_RETURN_LENGTH = 212; - uint256 internal constant CALL_CONTEXT_LENGTH = 6; + uint256 internal constant CALL_CONTEXT_LENGTH = 7; uint256 internal constant HISTORIC_BLOCK_DATA_LENGTH = 7; uint256 internal constant FUNCTION_DATA_LENGTH = 4; uint256 internal constant CONTRACT_DEPLOYMENT_DATA_LENGTH = 6; - uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 122; - uint256 internal constant CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 3; - uint256 internal constant CONTRACT_STORAGE_READ_LENGTH = 2; - uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = 141; + uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 221; + uint256 internal constant CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 4; + uint256 internal constant CONTRACT_STORAGE_READ_LENGTH = 3; + uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = 232; uint256 internal constant GET_NOTES_ORACLE_RETURN_LENGTH = 674; uint256 internal constant EMPTY_NULLIFIED_COMMITMENT = 1000000; - uint256 internal constant CALL_PRIVATE_FUNCTION_RETURN_SIZE = 128; - uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 87; - uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 112; + uint256 internal constant CALL_PRIVATE_FUNCTION_RETURN_SIZE = 227; + uint256 internal constant PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 145; + uint256 internal constant PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 210; uint256 internal constant COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP = 4096; uint256 internal constant NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP = 4096; uint256 internal constant PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP = 2048; diff --git a/yarn-project/aztec-nr/aztec/src/abi.nr b/yarn-project/aztec-nr/aztec/src/abi.nr index 821bde4c3946..d4fd85bb325c 100644 --- a/yarn-project/aztec-nr/aztec/src/abi.nr +++ b/yarn-project/aztec-nr/aztec/src/abi.nr @@ -70,6 +70,14 @@ impl SideEffect { fn serialize(self) -> [Field; 2] { [self.value, self.side_effect_counter] } + + fn deserialise(values: [Field; 2]) -> Self { + Self { + value: values[0], + side_effect_counter: values[1], + } + } + //fn hash(self) -> Field { // // no generator index to hash these... // dep::std::hash::pedersen_with_separator(self.serialize(), 2)[0] @@ -94,6 +102,15 @@ impl SideEffectLinkedToNoteHash { fn serialize(self) -> [Field; 3] { [self.value, self.note_hash, self.side_effect_counter] } + + fn deserialise(values: [Field; 3]) -> Self { + Self { + value: values[0], + note_hash: values[1], + side_effect_counter: values[2], + } + } + //fn hash(self) -> Field { // // no generator index to hash these... // dep::std::hash::pedersen_with_separator(self.serialize(), 3)[0] @@ -117,6 +134,15 @@ impl SideEffectWithRange { fn serialize(self) -> [Field; 3] { [self.value, self.start_side_effect_counter, self.end_side_effect_counter] } + + fn deserialise(values: [Field; 3]) -> Self { + Self { + value: values[0], + start_side_effect_counter: values[1], + end_side_effect_counter: values[2], + } + } + //fn hash(self) -> Field { // // no generator index to hash these... // dep::std::hash::pedersen_with_separator(self.serialize(), 3)[0] @@ -190,6 +216,8 @@ struct CallContext { is_delegate_call : bool, is_static_call : bool, is_contract_deployment: bool, + + start_side_effect_counter: Field, } // docs:end:call-context @@ -202,6 +230,7 @@ impl CallContext { self.is_delegate_call as Field, self.is_static_call as Field, self.is_contract_deployment as Field, + self.start_side_effect_counter, ] } @@ -316,6 +345,7 @@ impl PrivateCircuitPublicInputs { fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments); fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers); // TODO(dbanks12): should nullified commitments be here! + fields.push_array(self.nullified_commitments); fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack); fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack); fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs); diff --git a/yarn-project/aztec-nr/aztec/src/constants_gen.nr b/yarn-project/aztec-nr/aztec/src/constants_gen.nr index 6764ee657c33..3a7ae7d8d29e 100644 --- a/yarn-project/aztec-nr/aztec/src/constants_gen.nr +++ b/yarn-project/aztec-nr/aztec/src/constants_gen.nr @@ -52,19 +52,19 @@ global MAX_NOTE_FIELDS_LENGTH: Field = 20; global GET_NOTE_ORACLE_RETURN_LENGTH: Field = 23; global MAX_NOTES_PER_PAGE: Field = 10; global VIEW_NOTE_ORACLE_RETURN_LENGTH: Field = 212; -global CALL_CONTEXT_LENGTH: Field = 6; +global CALL_CONTEXT_LENGTH: Field = 7; global HISTORIC_BLOCK_DATA_LENGTH: Field = 7; global FUNCTION_DATA_LENGTH: Field = 4; global CONTRACT_DEPLOYMENT_DATA_LENGTH: Field = 6; -global PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 122; -global CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 3; -global CONTRACT_STORAGE_READ_LENGTH: Field = 2; -global PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 141; +global PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 221; +global CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH: Field = 4; +global CONTRACT_STORAGE_READ_LENGTH: Field = 3; +global PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH: Field = 232; global GET_NOTES_ORACLE_RETURN_LENGTH: Field = 674; global EMPTY_NULLIFIED_COMMITMENT: Field = 1000000; -global CALL_PRIVATE_FUNCTION_RETURN_SIZE: Field = 128; -global PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 87; -global PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 112; +global CALL_PRIVATE_FUNCTION_RETURN_SIZE: Field = 227; +global PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 145; +global PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH: Field = 210; global COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP: Field = 4096; global NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP: Field = 4096; global PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP: Field = 2048; diff --git a/yarn-project/aztec-nr/aztec/src/context.nr b/yarn-project/aztec-nr/aztec/src/context.nr index 9705b8dc6427..1bda3f8333b5 100644 --- a/yarn-project/aztec-nr/aztec/src/context.nr +++ b/yarn-project/aztec-nr/aztec/src/context.nr @@ -40,7 +40,7 @@ use crate::types::{ point::Point, }; -use crate::utils::arr_copy_slice; +use crate::utils::{arr_copy_slice, arr_copy_slice_in_struct_dumb2, arr_copy_slice_in_struct_dumb3}; use crate::oracle::{ arguments, @@ -65,6 +65,8 @@ struct PrivateContext { new_commitments: BoundedVec, new_nullifiers: BoundedVec, + // TODO(dbanks12): remove me! + nullified_commitments: BoundedVec, private_call_stack : BoundedVec, public_call_stack : BoundedVec, @@ -166,7 +168,7 @@ impl PrivateContext { side_effect_counter: self.side_effect_counter }; self.read_requests.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } fn push_new_note_hash(&mut self, note_hash: Field) { @@ -175,7 +177,7 @@ impl PrivateContext { side_effect_counter: self.side_effect_counter }; self.new_commitments.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) { @@ -185,7 +187,7 @@ impl PrivateContext { side_effect_counter: self.side_effect_counter }; self.new_nullifiers.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; // TODO(dbanks12): remove me! self.nullified_commitments.push(nullified_commitment); } @@ -199,7 +201,7 @@ impl PrivateContext { side_effect_counter: self.side_effect_counter }; self.new_l2_to_l1_msgs.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } // PrivateContextInputs must be temporarily passed in to prevent too many unknowns @@ -281,43 +283,44 @@ impl PrivateContext { is_static_call : fields[9] as bool, is_contract_deployment: fields[10] as bool, - start_side_effect_counter: fields[11] as bool, + start_side_effect_counter: fields[11], }, // TODO handle the offsets as a variable incremented during extraction? - args_hash: fields[11], - return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 12), - read_requests: arr_copy_slice(fields, [0; MAX_READ_REQUESTS_PER_CALL], 16), - new_commitments: arr_copy_slice(fields, [0; MAX_NEW_COMMITMENTS_PER_CALL], 48), - new_nullifiers: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 64), - nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 80), - private_call_stack: arr_copy_slice(fields, [0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], 96), - public_call_stack: arr_copy_slice(fields, [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], 100), - new_l2_to_l1_msgs: arr_copy_slice(fields, [0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], 104), - encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 106), - unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 108), - encrypted_log_preimages_length: fields[110], - unencrypted_log_preimages_length: fields[111], + args_hash: fields[12], + return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 13), + read_requests: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_READ_REQUESTS_PER_CALL], SideEffect::deserialise, 17), + new_commitments: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL], SideEffect::deserialise, 81), + new_nullifiers: arr_copy_slice_in_struct_dumb3(fields, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL], SideEffectLinkedToNoteHash::deserialise, 113), + // TODO(dbanks12): remove me! + nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 161), + private_call_stack: arr_copy_slice_in_struct_dumb3(fields, [SideEffectWithRange::empty(); MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], SideEffectWithRange::deserialise, 177), + public_call_stack: arr_copy_slice_in_struct_dumb3(fields, [SideEffectWithRange::empty(); MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], SideEffectWithRange::deserialise, 189), + new_l2_to_l1_msgs: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_NEW_L2_TO_L1_MSGS_PER_CALL], SideEffect::deserialise, 201), + encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 205), + unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 207), + encrypted_log_preimages_length: fields[209], + unencrypted_log_preimages_length: fields[210], block_data: HistoricBlockData { // Must match order in `private_circuit_public_inputs.hpp` - private_data_tree_root : fields[112], - nullifier_tree_root : fields[113], - contract_tree_root : fields[114], - l1_to_l2_messages_tree_root : fields[115], - blocks_tree_root : fields[116], - public_data_tree_root: fields[117], - global_variables_hash: fields[118], + private_data_tree_root : fields[211], + nullifier_tree_root : fields[212], + contract_tree_root : fields[213], + l1_to_l2_messages_tree_root : fields[214], + blocks_tree_root : fields[215], + public_data_tree_root: fields[216], + global_variables_hash: fields[217], }, contract_deployment_data: ContractDeploymentData { - deployer_public_key: Point::new(fields[119], fields[120]), - constructor_vk_hash : fields[121], - function_tree_root : fields[122], - contract_address_salt : fields[123], - portal_contract_address : fields[124], + deployer_public_key: Point::new(fields[218], fields[219]), + constructor_vk_hash : fields[220], + function_tree_root : fields[221], + contract_address_salt : fields[222], + portal_contract_address : fields[223], }, - chain_id: fields[125], - version: fields[126], + chain_id: fields[224], + version: fields[225], }, - is_execution_request: fields[127] as bool, + is_execution_request: fields[226] as bool, }; assert(contract_address == item.contract_address); assert(function_selector == item.function_data.function_selector); @@ -338,11 +341,11 @@ impl PrivateContext { let side_effect = SideEffectWithRange { value: item.hash(), - start_side_effect_counter: self.inputs.side_effect_counter, + start_side_effect_counter: self.inputs.start_side_effect_counter, end_side_effect_counter: self.side_effect_counter, }; self.private_call_stack.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; item.public_inputs.return_values } @@ -395,7 +398,7 @@ impl PrivateContext { is_static_call : fields[9] as bool, is_contract_deployment: fields[10] as bool, - start_side_effect_counter: fields[11] as bool, + start_side_effect_counter: fields[11], }, args_hash: fields[12], return_values: [0; RETURN_VALUES_LENGTH], @@ -430,7 +433,7 @@ impl PrivateContext { let side_effect = SideEffectWithRange { value: item.hash(), - start_side_effect_counter: self.inputs.side_effect_counter, + start_side_effect_counter: self.inputs.start_side_effect_counter, end_side_effect_counter: self.side_effect_counter, }; self.public_call_stack.push(side_effect); @@ -446,6 +449,8 @@ use crate::abi::{ struct PublicContext { inputs: abi::PublicContextInputs, + side_effect_counter: Field, + args_hash : Field, return_values : BoundedVec, @@ -558,7 +563,7 @@ impl PublicContext { side_effect_counter: self.side_effect_counter }; self.new_commitments.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) { @@ -568,7 +573,7 @@ impl PublicContext { side_effect_counter: self.side_effect_counter }; self.new_nullifiers.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } fn message_portal(&mut self, content: Field) { @@ -577,7 +582,7 @@ impl PublicContext { side_effect_counter: self.side_effect_counter }; self.new_l2_to_l1_msgs.push(side_effect); - self.side_effect_counter++; + self.side_effect_counter = self.side_effect_counter + 1; } // PrivateContextInputs must be temporarily passed in to prevent too many unknowns diff --git a/yarn-project/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr b/yarn-project/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr index 4e767ceeeb71..994909633fb4 100644 --- a/yarn-project/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr +++ b/yarn-project/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr @@ -3,8 +3,8 @@ // args_hash + // crate::abi::FUNCTION_DATA_SIZE + // crate::abi::CALL_CONTEXT_SIZE + -// = 2 + 4 + 6 -global ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE: Field = 12; +// = 2 + 4 + 7 +global ENQUEUE_PUBLIC_FUNCTION_CALL_RETURN_SIZE: Field = 13; #[oracle(enqueuePublicFunctionCall)] fn enqueue_public_function_call_oracle( diff --git a/yarn-project/aztec-nr/aztec/src/state_vars/set.nr b/yarn-project/aztec-nr/aztec/src/state_vars/set.nr index 698af2ef11ca..21e762ff6ab9 100644 --- a/yarn-project/aztec-nr/aztec/src/state_vars/set.nr +++ b/yarn-project/aztec-nr/aztec/src/state_vars/set.nr @@ -1,5 +1,8 @@ use dep::std::option::Option; -use crate::abi::PublicContextInputs; +use crate::abi::{ + PublicContextInputs, + SideEffect, +}; use crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL}; use crate::context::{PrivateContext, PublicContext, Context}; use crate::note::{ @@ -118,7 +121,7 @@ impl Set { fn remove(self, note: Note) { let context = self.context.private.unwrap(); let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note); - let has_been_read = context.read_requests.any(|r| r == note_hash); + let has_been_read = context.read_requests.any(|r: SideEffect| r.value == note_hash); assert(has_been_read, "Can only remove a note that has been read from the set."); destroy_note( diff --git a/yarn-project/aztec-nr/aztec/src/types/vec.nr b/yarn-project/aztec-nr/aztec/src/types/vec.nr index 9442f9774398..bf87ee62c033 100644 --- a/yarn-project/aztec-nr/aztec/src/types/vec.nr +++ b/yarn-project/aztec-nr/aztec/src/types/vec.nr @@ -49,6 +49,20 @@ impl BoundedVec { } ret } + + fn flatten_and_push_array(&mut self, serialize: fn(S) -> [T; InnerLen], array: [S; Len]) { + let newLen = self.len + (array.len() * InnerLen); + assert(newLen as u64 <= MaxLen as u64); + for outer in 0..array.len() { + let inner_array = serialize(array[outer]); + self.push_array(inner_array); + // TODO: more efficient: + //for inner in 0..inner_array.len() { + // self.storage[self.len + (outer * InnerLen) + inner] = inner_array[inner]; + //} + } + } + } #[test] diff --git a/yarn-project/aztec-nr/aztec/src/utils.nr b/yarn-project/aztec-nr/aztec/src/utils.nr index 83b9863a2e30..1e3fd53d672a 100644 --- a/yarn-project/aztec-nr/aztec/src/utils.nr +++ b/yarn-project/aztec-nr/aztec/src/utils.nr @@ -7,4 +7,59 @@ fn arr_copy_slice( dst[i] = src[i + offset]; } dst +} + +// fn arr_copy_slice_in_struct_lol( +// src: [Field; N], +// mut dst: [U; M], +// deserialise: fn([Field; K]) -> U, +// offset: Field, +// ) -> [U; M] { +// for i in 0..dst.len() { +// let mut serialised = [0; K]; +// for j in 0..K { +// serialised[j] = src[offset + i * K + j]; +// } +// dst[i] = deserialise(serialised); +// } +// dst +// } + + +// fn arr_copy_slice_in_struct( +// src: [Field; N], +// mut dst: [U; M], +// deserialise: fn([Field; K]) -> U, +// offset: Field, +// ) -> [U; M] { +// for i in 0..dst.len() { +// let inner_array = arr_copy_slice(src, [0; K], offset + i * K); +// dst[i] = deserialise(inner_array); +// } +// dst +// } + +// TODO: Replace these with something smart. +fn arr_copy_slice_in_struct_dumb2( + src: [T; N], + mut dst: [U; M], + deserialise: fn([T; 2]) -> U, + offset: Field, +) -> [U; M] { + for i in 0..dst.len() { + dst[i] = deserialise([src[offset + 2 * i], src[offset + 2 * i + 1]]); + } + dst +} + +fn arr_copy_slice_in_struct_dumb3( + src: [T; N], + mut dst: [U; M], + deserialise: fn([T; 3]) -> U, + offset: Field, +) -> [U; M] { + for i in 0..dst.len() { + dst[i] = deserialise([src[offset + 2 * i], src[offset + 2 * i + 1], src[offset + 2 * i + 2]]); + } + dst } \ No newline at end of file diff --git a/yarn-project/circuits.js/src/cbind/circuits.gen.ts b/yarn-project/circuits.js/src/cbind/circuits.gen.ts index cc8b7726b00d..b0ee36331c2a 100644 --- a/yarn-project/circuits.js/src/cbind/circuits.gen.ts +++ b/yarn-project/circuits.js/src/cbind/circuits.gen.ts @@ -57,6 +57,9 @@ import { ReadRequestMembershipWitness, RootRollupInputs, RootRollupPublicInputs, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, TxContext, TxRequest, VerificationKeyData, @@ -566,13 +569,13 @@ export function fromPublicDataRead(o: PublicDataRead): MsgpackPublicDataRead { interface MsgpackCombinedAccumulatedData { aggregation_object: MsgpackNativeAggregationState; - read_requests: Tuple; - new_commitments: Tuple; - new_nullifiers: Tuple; + read_requests: Tuple; + new_commitments: Tuple; + new_nullifiers: Tuple; nullified_commitments: Tuple; - private_call_stack: Tuple; - public_call_stack: Tuple; - new_l2_to_l1_msgs: Tuple; + private_call_stack: Tuple; + public_call_stack: Tuple; + new_l2_to_l1_msgs: Tuple; encrypted_logs_hash: Tuple; unencrypted_logs_hash: Tuple; encrypted_log_preimages_length: Buffer; @@ -1212,6 +1215,7 @@ interface MsgpackCallContext { is_delegate_call: boolean; is_static_call: boolean; is_contract_deployment: boolean; + start_side_effect_counter: Buffer; } export function toCallContext(o: MsgpackCallContext): CallContext { @@ -1233,6 +1237,9 @@ export function toCallContext(o: MsgpackCallContext): CallContext { if (o.is_contract_deployment === undefined) { throw new Error('Expected is_contract_deployment in CallContext deserialization'); } + if (o.start_side_effect_counter === undefined) { + throw new Error('Expected start_side_effect_counter in CallContext deserialization'); + } return new CallContext( Address.fromBuffer(o.msg_sender), Address.fromBuffer(o.storage_contract_address), @@ -1240,6 +1247,7 @@ export function toCallContext(o: MsgpackCallContext): CallContext { o.is_delegate_call, o.is_static_call, o.is_contract_deployment, + Fr.fromBuffer(o.start_side_effect_counter), ); } @@ -1262,6 +1270,9 @@ export function fromCallContext(o: CallContext): MsgpackCallContext { if (o.isContractDeployment === undefined) { throw new Error('Expected isContractDeployment in CallContext serialization'); } + if (o.startSideEffectCounter === undefined) { + throw new Error('Expected startSideEffectCounter in CallContext serialization'); + } return { msg_sender: toBuffer(o.msgSender), storage_contract_address: toBuffer(o.storageContractAddress), @@ -1269,6 +1280,7 @@ export function fromCallContext(o: CallContext): MsgpackCallContext { is_delegate_call: o.isDelegateCall, is_static_call: o.isStaticCall, is_contract_deployment: o.isContractDeployment, + start_side_effect_counter: toBuffer(o.startSideEffectCounter), }; } @@ -1276,13 +1288,13 @@ interface MsgpackPrivateCircuitPublicInputs { call_context: MsgpackCallContext; args_hash: Buffer; return_values: Tuple; - read_requests: Tuple; - new_commitments: Tuple; - new_nullifiers: Tuple; + read_requests: Tuple; + new_commitments: Tuple; + new_nullifiers: Tuple; nullified_commitments: Tuple; - private_call_stack: Tuple; - public_call_stack: Tuple; - new_l2_to_l1_msgs: Tuple; + private_call_stack: Tuple; + public_call_stack: Tuple; + new_l2_to_l1_msgs: Tuple; encrypted_logs_hash: Tuple; unencrypted_logs_hash: Tuple; encrypted_log_preimages_length: Buffer; @@ -1833,12 +1845,12 @@ export function fromPrivateKernelInputsOrdering(o: PrivateKernelInputsOrdering): interface MsgpackFinalAccumulatedData { aggregation_object: MsgpackNativeAggregationState; - new_commitments: Tuple; - new_nullifiers: Tuple; + new_commitments: Tuple; + new_nullifiers: Tuple; nullified_commitments: Tuple; - private_call_stack: Tuple; - public_call_stack: Tuple; - new_l2_to_l1_msgs: Tuple; + private_call_stack: Tuple; + public_call_stack: Tuple; + new_l2_to_l1_msgs: Tuple; encrypted_logs_hash: Tuple; unencrypted_logs_hash: Tuple; encrypted_log_preimages_length: Buffer; @@ -2081,10 +2093,10 @@ interface MsgpackPublicCircuitPublicInputs { return_values: Tuple; contract_storage_update_requests: Tuple; contract_storage_reads: Tuple; - public_call_stack: Tuple; - new_commitments: Tuple; - new_nullifiers: Tuple; - new_l2_to_l1_msgs: Tuple; + public_call_stack: Tuple; + new_commitments: Tuple; + new_nullifiers: Tuple; + new_l2_to_l1_msgs: Tuple; unencrypted_logs_hash: Tuple; unencrypted_log_preimages_length: Buffer; historic_block_data: MsgpackHistoricBlockData; diff --git a/yarn-project/circuits.js/src/cbind/constants.gen.ts b/yarn-project/circuits.js/src/cbind/constants.gen.ts index 1631800e6337..25a0dcc51b5e 100644 --- a/yarn-project/circuits.js/src/cbind/constants.gen.ts +++ b/yarn-project/circuits.js/src/cbind/constants.gen.ts @@ -53,19 +53,19 @@ export const MAX_NOTE_FIELDS_LENGTH = 20; export const GET_NOTE_ORACLE_RETURN_LENGTH = 23; export const MAX_NOTES_PER_PAGE = 10; export const VIEW_NOTE_ORACLE_RETURN_LENGTH = 212; -export const CALL_CONTEXT_LENGTH = 6; +export const CALL_CONTEXT_LENGTH = 7; export const HISTORIC_BLOCK_DATA_LENGTH = 7; export const FUNCTION_DATA_LENGTH = 4; export const CONTRACT_DEPLOYMENT_DATA_LENGTH = 6; -export const PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 122; -export const CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 3; -export const CONTRACT_STORAGE_READ_LENGTH = 2; -export const PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = 141; +export const PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = 221; +export const CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 4; +export const CONTRACT_STORAGE_READ_LENGTH = 3; +export const PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = 232; export const GET_NOTES_ORACLE_RETURN_LENGTH = 674; export const EMPTY_NULLIFIED_COMMITMENT = 1000000; -export const CALL_PRIVATE_FUNCTION_RETURN_SIZE = 128; -export const PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 87; -export const PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 112; +export const CALL_PRIVATE_FUNCTION_RETURN_SIZE = 227; +export const PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 145; +export const PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 210; export const COMMITMENTS_NUM_BYTES_PER_BASE_ROLLUP = 4096; export const NULLIFIERS_NUM_BYTES_PER_BASE_ROLLUP = 4096; export const PUBLIC_DATA_WRITES_NUM_BYTES_PER_BASE_ROLLUP = 2048; diff --git a/yarn-project/circuits.js/src/structs/call_context.ts b/yarn-project/circuits.js/src/structs/call_context.ts index cb64dac8d44a..55383548ed7b 100644 --- a/yarn-project/circuits.js/src/structs/call_context.ts +++ b/yarn-project/circuits.js/src/structs/call_context.ts @@ -43,6 +43,10 @@ export class CallContext { * Determines whether the call is a contract deployment. */ public isContractDeployment: boolean, + /** + * The start side effect counter for this call context. + */ + public startSideEffectCounter: Fr, ) { this.portalContractAddress = portalContractAddress instanceof EthAddress ? portalContractAddress : EthAddress.fromField(portalContractAddress); @@ -53,7 +57,7 @@ export class CallContext { * @returns A new instance of CallContext with zero msg sender, storage contract address and portal contract address. */ public static empty(): CallContext { - return new CallContext(AztecAddress.ZERO, AztecAddress.ZERO, Fr.ZERO, false, false, false); + return new CallContext(AztecAddress.ZERO, AztecAddress.ZERO, Fr.ZERO, false, false, false, Fr.ZERO); } isEmpty() { @@ -72,6 +76,7 @@ export class CallContext { fields.isDelegateCall, fields.isStaticCall, fields.isContractDeployment, + fields.startSideEffectCounter, ] as const; } @@ -97,6 +102,7 @@ export class CallContext { reader.readBoolean(), reader.readBoolean(), reader.readBoolean(), + new Fr(reader.readFr()), ); } } diff --git a/yarn-project/circuits.js/src/tests/factories.ts b/yarn-project/circuits.js/src/tests/factories.ts index 6b404f699633..6ba4af07cfe1 100644 --- a/yarn-project/circuits.js/src/tests/factories.ts +++ b/yarn-project/circuits.js/src/tests/factories.ts @@ -304,7 +304,15 @@ export function makeAggregationObject(seed = 1): AggregationObject { * @returns A call context. */ export function makeCallContext(seed = 0, storageContractAddress = makeAztecAddress(seed + 1)): CallContext { - return new CallContext(makeAztecAddress(seed), storageContractAddress, makeEthAddress(seed + 2), false, false, false); + return new CallContext( + makeAztecAddress(seed), + storageContractAddress, + makeEthAddress(seed + 2), + false, + false, + false, + fr(0), + ); } /** @@ -655,6 +663,7 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn true, true, true, + fr(0), ), argsHash: fr(seed + 0x100), returnValues: makeTuple(RETURN_VALUES_LENGTH, fr, seed + 0x200), From 6549c6002b32d89eaf750f7461e5f988f72ff82f Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Wed, 27 Sep 2023 17:37:23 +0000 Subject: [PATCH 3/7] acir simulator fixes (initial witness), start fixing TS to use these objects instead of fields --- .../acir-simulator/src/acvm/deserialize.ts | 64 +++++- .../acir-simulator/src/acvm/serialize.ts | 13 +- .../src/client/client_execution_context.ts | 8 +- .../src/client/private_execution.test.ts | 59 ++--- .../src/client/private_execution.ts | 4 + .../acir-simulator/src/client/simulator.ts | 2 + .../acir-simulator/src/public/execution.ts | 8 +- .../acir-simulator/src/public/executor.ts | 7 +- .../acir-simulator/src/public/index.test.ts | 7 + yarn-project/aztec-nr/aztec/src/context.nr | 1 - .../src/abis/ecdsa_account_contract.json | 208 ++++++++++++++++-- .../src/abis/schnorr_account_contract.json | 208 ++++++++++++++++-- .../schnorr_single_key_account_contract.json | 206 +++++++++++++++-- .../circuits.js/src/structs/side_effects.ts | 65 +++++- yarn-project/types/src/tx/tx.ts | 2 +- 15 files changed, 761 insertions(+), 101 deletions(-) diff --git a/yarn-project/acir-simulator/src/acvm/deserialize.ts b/yarn-project/acir-simulator/src/acvm/deserialize.ts index c9d0f540526e..c3d19888429c 100644 --- a/yarn-project/acir-simulator/src/acvm/deserialize.ts +++ b/yarn-project/acir-simulator/src/acvm/deserialize.ts @@ -16,6 +16,9 @@ import { PrivateCircuitPublicInputs, PublicCircuitPublicInputs, RETURN_VALUES_LENGTH, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, } from '@aztec/circuits.js'; import { AztecAddress } from '@aztec/foundation/aztec-address'; import { EthAddress } from '@aztec/foundation/eth-address'; @@ -101,6 +104,45 @@ export class PublicInputsReader { } return array as Tuple; } + + /** + * Reads an array of SideEffects from the public inputs. + * @param length - The length of the array. + * @returns The array of SideEffects. + */ + public readSideEffectArray(length: N): Tuple { + const array: SideEffect[] = []; + for (let i = 0; i < length; i++) { + array.push(new SideEffect(this.readField(), this.readField())); + } + return array as Tuple; + } + + /** + * Reads an array of SideEffectLinkedToNoteHashes from the public inputs. + * @param length - The length of the array. + * @returns The array of SideEffectLinkedToNoteHashes. + */ + public readSideEffectLinkedToNoteHashArray(length: N): Tuple { + const array: SideEffectLinkedToNoteHash[] = []; + for (let i = 0; i < length; i++) { + array.push(new SideEffectLinkedToNoteHash(this.readField(), this.readField(), this.readField())); + } + return array as Tuple; + } + + /** + * Reads an array of SideEffectWithRanges from the public inputs. + * @param length - The length of the array. + * @returns The array of SideEffectWithRanges. + */ + public readSideEffectWithRangeArray(length: N): Tuple { + const array: SideEffectWithRange[] = []; + for (let i = 0; i < length; i++) { + array.push(new SideEffectWithRange(this.readField(), this.readField(), this.readField())); + } + return array as Tuple; + } } /** @@ -122,17 +164,18 @@ export function extractPrivateCircuitPublicInputs( frToBoolean(witnessReader.readField()), frToBoolean(witnessReader.readField()), frToBoolean(witnessReader.readField()), + witnessReader.readField(), ); const argsHash = witnessReader.readField(); const returnValues = witnessReader.readFieldArray(RETURN_VALUES_LENGTH); - const readRequests = witnessReader.readFieldArray(MAX_READ_REQUESTS_PER_CALL); - const newCommitments = witnessReader.readFieldArray(MAX_NEW_COMMITMENTS_PER_CALL); - const newNullifiers = witnessReader.readFieldArray(MAX_NEW_NULLIFIERS_PER_CALL); + const readRequests = witnessReader.readSideEffectArray(MAX_READ_REQUESTS_PER_CALL); + const newCommitments = witnessReader.readSideEffectArray(MAX_NEW_COMMITMENTS_PER_CALL); + const newNullifiers = witnessReader.readSideEffectLinkedToNoteHashArray(MAX_NEW_NULLIFIERS_PER_CALL); const nullifiedCommitments = witnessReader.readFieldArray(MAX_NEW_NULLIFIERS_PER_CALL); - const privateCallStack = witnessReader.readFieldArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL); - const publicCallStack = witnessReader.readFieldArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL); - const newL2ToL1Msgs = witnessReader.readFieldArray(MAX_NEW_L2_TO_L1_MSGS_PER_CALL); + const privateCallStack = witnessReader.readSideEffectWithRangeArray(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL); + const publicCallStack = witnessReader.readSideEffectWithRangeArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL); + const newL2ToL1Msgs = witnessReader.readSideEffectArray(MAX_NEW_L2_TO_L1_MSGS_PER_CALL); const encryptedLogsHash = witnessReader.readFieldArray(NUM_FIELDS_PER_SHA256); const unencryptedLogsHash = witnessReader.readFieldArray(NUM_FIELDS_PER_SHA256); @@ -199,6 +242,7 @@ export function extractPublicCircuitPublicInputs(partialWitness: ACVMWitness, ac frToBoolean(witnessReader.readField()), frToBoolean(witnessReader.readField()), frToBoolean(witnessReader.readField()), + witnessReader.readField(), ); const argsHash = witnessReader.readField(); @@ -221,10 +265,10 @@ export function extractPublicCircuitPublicInputs(partialWitness: ACVMWitness, ac contractStorageReads[i] = request; } - const publicCallStack = witnessReader.readFieldArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL); - const newCommitments = witnessReader.readFieldArray(MAX_NEW_COMMITMENTS_PER_CALL); - const newNullifiers = witnessReader.readFieldArray(MAX_NEW_NULLIFIERS_PER_CALL); - const newL2ToL1Msgs = witnessReader.readFieldArray(MAX_NEW_L2_TO_L1_MSGS_PER_CALL); + const publicCallStack = witnessReader.readSideEffectWithRangeArray(MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL); + const newCommitments = witnessReader.readSideEffectArray(MAX_NEW_COMMITMENTS_PER_CALL); + const newNullifiers = witnessReader.readSideEffectLinkedToNoteHashArray(MAX_NEW_NULLIFIERS_PER_CALL); + const newL2ToL1Msgs = witnessReader.readSideEffectArray(MAX_NEW_L2_TO_L1_MSGS_PER_CALL); const unencryptedLogsHash = witnessReader.readFieldArray(NUM_FIELDS_PER_SHA256); const unencryptedLogPreimagesLength = witnessReader.readField(); diff --git a/yarn-project/acir-simulator/src/acvm/serialize.ts b/yarn-project/acir-simulator/src/acvm/serialize.ts index 00ca0d9de485..85b8ac55f5e1 100644 --- a/yarn-project/acir-simulator/src/acvm/serialize.ts +++ b/yarn-project/acir-simulator/src/acvm/serialize.ts @@ -15,6 +15,7 @@ import { ACVMField, toACVMField } from './acvm.js'; // Utilities to write TS classes to ACVM Field arrays // In the order that the ACVM expects them + /** * Converts a function data to ACVM fields. * @param functionData - The function data to convert. @@ -89,13 +90,13 @@ export function toACVMPublicInputs(publicInputs: PrivateCircuitPublicInputs): AC toACVMField(publicInputs.argsHash), ...publicInputs.returnValues.map(toACVMField), - ...publicInputs.readRequests.map(toACVMField), - ...publicInputs.newCommitments.map(toACVMField), - ...publicInputs.newNullifiers.map(toACVMField), + ...publicInputs.readRequests.flatMap(x => x.toFieldArray().map(toACVMField)), + ...publicInputs.newCommitments.flatMap(x => x.toFieldArray().map(toACVMField)), + ...publicInputs.newNullifiers.flatMap(x => x.toFieldArray().map(toACVMField)), ...publicInputs.nullifiedCommitments.map(toACVMField), - ...publicInputs.privateCallStack.map(toACVMField), - ...publicInputs.publicCallStack.map(toACVMField), - ...publicInputs.newL2ToL1Msgs.map(toACVMField), + ...publicInputs.privateCallStack.flatMap(x => x.toFieldArray().map(toACVMField)), + ...publicInputs.publicCallStack.flatMap(x => x.toFieldArray().map(toACVMField)), + ...publicInputs.newL2ToL1Msgs.flatMap(x => x.toFieldArray().map(toACVMField)), ...publicInputs.encryptedLogsHash.map(toACVMField), ...publicInputs.unencryptedLogsHash.map(toACVMField), diff --git a/yarn-project/acir-simulator/src/client/client_execution_context.ts b/yarn-project/acir-simulator/src/client/client_execution_context.ts index 63c720a74975..6efd7b654e70 100644 --- a/yarn-project/acir-simulator/src/client/client_execution_context.ts +++ b/yarn-project/acir-simulator/src/client/client_execution_context.ts @@ -1,4 +1,4 @@ -import { CircuitsWasm, HistoricBlockData, ReadRequestMembershipWitness, TxContext } from '@aztec/circuits.js'; +import { CircuitsWasm, HistoricBlockData, ReadRequestMembershipWitness, SideEffect, TxContext } from '@aztec/circuits.js'; import { computeUniqueCommitment, siloCommitment } from '@aztec/circuits.js/abis'; import { AztecAddress } from '@aztec/foundation/aztec-address'; import { Fr, Point } from '@aztec/foundation/fields'; @@ -96,11 +96,11 @@ export class ClientTxExecutionContext { * @param readRequests - Note hashed of the notes being read. * @returns An array of partially filled in read request membership witnesses. */ - public getReadRequestPartialWitnesses(readRequests: Fr[]) { + public getReadRequestPartialWitnesses(readRequests: SideEffect[]) { return readRequests - .filter(r => !r.isZero()) + .filter(r => !r.isEmpty()) .map(r => { - const index = this.gotNotes.get(r.value); + const index = this.gotNotes.get(r.value.value); // .value once for field in SideEffect, second time for bigint value of field return index !== undefined ? ReadRequestMembershipWitness.empty(index) : ReadRequestMembershipWitness.emptyTransient(); diff --git a/yarn-project/acir-simulator/src/client/private_execution.test.ts b/yarn-project/acir-simulator/src/client/private_execution.test.ts index 59c3993460dd..c358f78c75f2 100644 --- a/yarn-project/acir-simulator/src/client/private_execution.test.ts +++ b/yarn-project/acir-simulator/src/client/private_execution.test.ts @@ -12,6 +12,8 @@ import { PublicCallRequest, PublicKey, TxContext, + nonEmptySideEffects, + sideEffectArrayToValueArray, } from '@aztec/circuits.js'; import { computeCallStackItemHash, @@ -177,7 +179,7 @@ describe('Private Execution test suite', () => { const result = await runSimulator({ abi, txContext }); const emptyCommitments = new Array(MAX_NEW_COMMITMENTS_PER_CALL).fill(Fr.ZERO); - expect(result.callStackItem.publicInputs.newCommitments).toEqual(emptyCommitments); + expect(sideEffectArrayToValueArray(result.callStackItem.publicInputs.newCommitments)).toEqual(emptyCommitments); expect(result.callStackItem.publicInputs.contractDeploymentData).toEqual(contractDeploymentData); }); }); @@ -273,7 +275,7 @@ describe('Private Execution test suite', () => { const newNote = result.newNotes[0]; expect(newNote.storageSlot).toEqual(computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const [commitment] = newCommitments; @@ -291,7 +293,7 @@ describe('Private Execution test suite', () => { const newNote = result.newNotes[0]; expect(newNote.storageSlot).toEqual(computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const [commitment] = newCommitments; @@ -319,7 +321,7 @@ describe('Private Execution test suite', () => { const result = await runSimulator({ args, abi, msgSender: owner }); // The two notes were nullified - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toHaveLength(consumedNotes.length); expect(newNullifiers).toEqual(expect.arrayContaining(consumedNotes.map(n => n.innerNullifier))); @@ -327,7 +329,7 @@ describe('Private Execution test suite', () => { const [changeNote, recipientNote] = result.newNotes; expect(recipientNote.storageSlot).toEqual(recipientStorageSlot); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(2); const [changeNoteCommitment, recipientNoteCommitment] = newCommitments; @@ -341,7 +343,7 @@ describe('Private Execution test suite', () => { expect(recipientNote.preimage[0]).toEqual(new Fr(amountToTransfer)); expect(changeNote.preimage[0]).toEqual(new Fr(40n)); - const readRequests = result.callStackItem.publicInputs.readRequests.filter(field => !field.equals(Fr.ZERO)); + const readRequests = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.readRequests)); expect(readRequests).toHaveLength(consumedNotes.length); expect(readRequests).toEqual(expect.arrayContaining(consumedNotes.map(n => n.uniqueSiloedNoteHash))); }); @@ -364,7 +366,7 @@ describe('Private Execution test suite', () => { const args = [amountToTransfer, recipient]; const result = await runSimulator({ args, abi, msgSender: owner }); - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toEqual(consumedNotes.map(n => n.innerNullifier)); expect(result.newNotes).toHaveLength(2); @@ -390,11 +392,11 @@ describe('Private Execution test suite', () => { }); // Check a nullifier has been inserted. - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toHaveLength(1); // Check the read request was inserted successfully. - const readRequests = result.callStackItem.publicInputs.readRequests.filter(field => !field.equals(Fr.ZERO)); + const readRequests = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.readRequests)); const siloedNoteHash = siloCommitment(circuitsWasm, contractAddress, innerNoteHash); const uniqueSiloedNoteHash = computeUniqueCommitment(circuitsWasm, nonce, siloedNoteHash); expect(readRequests).toEqual([uniqueSiloedNoteHash]); @@ -492,7 +494,7 @@ describe('Private Execution test suite', () => { const newNote = result.newNotes[0]; expect(newNote.storageSlot).toEqual(computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const [commitment] = newCommitments; @@ -510,7 +512,7 @@ describe('Private Execution test suite', () => { const newNote = result.newNotes[0]; expect(newNote.storageSlot).toEqual(computeSlotForMapping(new Fr(1n), owner.toField(), circuitsWasm)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const [commitment] = newCommitments; @@ -538,7 +540,7 @@ describe('Private Execution test suite', () => { const result = await runSimulator({ args, abi, msgSender: owner }); // The two notes were nullified - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toHaveLength(consumedNotes.length); expect(newNullifiers).toEqual(expect.arrayContaining(consumedNotes.map(n => n.innerNullifier))); @@ -546,7 +548,7 @@ describe('Private Execution test suite', () => { const [changeNote, recipientNote] = result.newNotes; expect(recipientNote.storageSlot).toEqual(recipientStorageSlot); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(2); const [changeNoteCommitment, recipientNoteCommitment] = newCommitments; @@ -560,7 +562,7 @@ describe('Private Execution test suite', () => { expect(recipientNote.preimage[0]).toEqual(new Fr(amountToTransfer)); expect(changeNote.preimage[0]).toEqual(new Fr(40n)); - const readRequests = result.callStackItem.publicInputs.readRequests.filter(field => !field.equals(Fr.ZERO)); + const readRequests = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.readRequests)); expect(readRequests).toHaveLength(consumedNotes.length); expect(readRequests).toEqual(expect.arrayContaining(consumedNotes.map(n => n.uniqueSiloedNoteHash))); }); @@ -583,7 +585,7 @@ describe('Private Execution test suite', () => { const args = [recipient, amountToTransfer]; const result = await runSimulator({ args, abi, msgSender: owner }); - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toEqual(consumedNotes.map(n => n.innerNullifier)); expect(result.newNotes).toHaveLength(2); @@ -718,7 +720,7 @@ describe('Private Execution test suite', () => { const result = await runSimulator({ contractAddress, abi, args }); // Check a nullifier has been inserted - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toHaveLength(1); }); @@ -742,11 +744,11 @@ describe('Private Execution test suite', () => { }); // Check a nullifier has been inserted. - const newNullifiers = result.callStackItem.publicInputs.newNullifiers.filter(field => !field.equals(Fr.ZERO)); + const newNullifiers = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newNullifiers)); expect(newNullifiers).toHaveLength(1); // Check the commitment read request was created successfully. - const readRequests = result.callStackItem.publicInputs.readRequests.filter(field => !field.equals(Fr.ZERO)); + const readRequests = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.readRequests)); expect(readRequests).toHaveLength(1); expect(readRequests[0]).toEqual(siloedNoteHash); }); @@ -787,6 +789,7 @@ describe('Private Execution test suite', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, // TODO(dbanks12): set this to the right value }), sideEffectCounter: 0, }); @@ -843,7 +846,7 @@ describe('Private Execution test suite', () => { expect(note.preimage[0]).toEqual(new Fr(amountToTransfer)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const commitment = newCommitments[0]; @@ -852,13 +855,13 @@ describe('Private Execution test suite', () => { expect(commitment).toEqual(innerNoteHash); // read request should match innerNoteHash for pending notes (there is no nonce, so can't compute "unique" hash) - const readRequest = result.callStackItem.publicInputs.readRequests[0]; + const readRequest = result.callStackItem.publicInputs.readRequests[0].value; expect(readRequest).toEqual(innerNoteHash); const gotNoteValue = result.callStackItem.publicInputs.returnValues[0].value; expect(gotNoteValue).toEqual(amountToTransfer); - const nullifier = result.callStackItem.publicInputs.newNullifiers[0]; + const nullifier = result.callStackItem.publicInputs.newNullifiers[0].value; expect(nullifier).toEqual( await acirSimulator.computeInnerNullifier(contractAddress, Fr.ZERO, note.storageSlot, note.preimage), ); @@ -909,9 +912,7 @@ describe('Private Execution test suite', () => { expect(note.preimage[0]).toEqual(new Fr(amountToTransfer)); - const newCommitments = execInsert.callStackItem.publicInputs.newCommitments.filter( - field => !field.equals(Fr.ZERO), - ); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(execInsert.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const commitment = newCommitments[0]; @@ -920,14 +921,14 @@ describe('Private Execution test suite', () => { expect(commitment).toEqual(innerNoteHash); // read request should match innerNoteHash for pending notes (there is no nonce, so can't compute "unique" hash) - const readRequest = execGetThenNullify.callStackItem.publicInputs.readRequests[0]; + const readRequest = execGetThenNullify.callStackItem.publicInputs.readRequests[0].value; expect(readRequest).toEqual(innerNoteHash); const gotNoteValue = execGetThenNullify.callStackItem.publicInputs.returnValues[0].value; expect(gotNoteValue).toEqual(amountToTransfer); const nonce = Fr.ZERO; - const nullifier = execGetThenNullify.callStackItem.publicInputs.newNullifiers[0]; + const nullifier = execGetThenNullify.callStackItem.publicInputs.newNullifiers[0].value; expect(nullifier).toEqual( await acirSimulator.computeInnerNullifier(contractAddress, nonce, note.storageSlot, note.preimage), ); @@ -958,7 +959,7 @@ describe('Private Execution test suite', () => { expect(note.preimage[0]).toEqual(new Fr(amountToTransfer)); - const newCommitments = result.callStackItem.publicInputs.newCommitments.filter(field => !field.equals(Fr.ZERO)); + const newCommitments = sideEffectArrayToValueArray(nonEmptySideEffects(result.callStackItem.publicInputs.newCommitments)); expect(newCommitments).toHaveLength(1); const commitment = newCommitments[0]; @@ -966,7 +967,7 @@ describe('Private Execution test suite', () => { expect(commitment).toEqual(await acirSimulator.computeInnerNoteHash(contractAddress, storageSlot, note.preimage)); // read requests should be empty - const readRequest = result.callStackItem.publicInputs.readRequests[0].value; + const readRequest = result.callStackItem.publicInputs.readRequests[0].value.value; // .value once to get Fr from SideEffect, twice to get inner value from Fr expect(readRequest).toEqual(0n); // should get note value 0 because it actually gets a fake note since the real one hasn't been inserted yet! @@ -974,7 +975,7 @@ describe('Private Execution test suite', () => { expect(gotNoteValue).toEqual(0n); // there should be no nullifiers - const nullifier = result.callStackItem.publicInputs.newNullifiers[0].value; + const nullifier = result.callStackItem.publicInputs.newNullifiers[0].value.value; // .value once to get Fr from SideEffect, twice to get inner value from Fr expect(nullifier).toEqual(0n); }); }); diff --git a/yarn-project/acir-simulator/src/client/private_execution.ts b/yarn-project/acir-simulator/src/client/private_execution.ts index 64516e8fde91..60bb1c70347b 100644 --- a/yarn-project/acir-simulator/src/client/private_execution.ts +++ b/yarn-project/acir-simulator/src/client/private_execution.ts @@ -240,6 +240,7 @@ export class PrivateFunctionExecution { this.callContext.isDelegateCall, this.callContext.isStaticCall, this.callContext.isContractDeployment, + this.callContext.startSideEffectCounter, ...blockData.toArray(), @@ -253,6 +254,8 @@ export class PrivateFunctionExecution { this.context.txContext.chainId, this.context.txContext.version, + this.sideEffectCounter, + ...this.context.packedArgsCache.unpack(this.argsHash), ]; @@ -350,6 +353,7 @@ export class PrivateFunctionExecution { isDelegateCall, isStaticCall, false, + Fr.ZERO, // TODO(dbanks12): need to pass in the correct value here ); } } diff --git a/yarn-project/acir-simulator/src/client/simulator.ts b/yarn-project/acir-simulator/src/client/simulator.ts index f00be81213ed..188f309ad036 100644 --- a/yarn-project/acir-simulator/src/client/simulator.ts +++ b/yarn-project/acir-simulator/src/client/simulator.ts @@ -83,6 +83,7 @@ export class AcirSimulator { false, false, request.functionData.isConstructor, + Fr.ZERO, // TODO(dbanks12): need to pass in the correct value here ); const execution = new PrivateFunctionExecution( @@ -139,6 +140,7 @@ export class AcirSimulator { false, false, request.functionData.isConstructor, + Fr.ZERO, // TODO(dbanks12): need to pass in the correct value here ); const execution = new UnconstrainedFunctionExecution( diff --git a/yarn-project/acir-simulator/src/public/execution.ts b/yarn-project/acir-simulator/src/public/execution.ts index e26dba8831d9..e8ec864eb0f8 100644 --- a/yarn-project/acir-simulator/src/public/execution.ts +++ b/yarn-project/acir-simulator/src/public/execution.ts @@ -7,6 +7,8 @@ import { FunctionData, PublicDataRead, PublicDataUpdateRequest, + SideEffect, + SideEffectLinkedToNoteHash, } from '@aztec/circuits.js'; import { computePublicDataTreeIndex, computePublicDataTreeValue } from '@aztec/circuits.js/abis'; import { IWasmModule } from '@aztec/foundation/wasm'; @@ -21,11 +23,11 @@ export interface PublicExecutionResult { /** The return values of the function. */ returnValues: Fr[]; /** The new commitments to be inserted into the commitments tree. */ - newCommitments: Fr[]; + newCommitments: SideEffect[]; /** The new l2 to l1 messages generated in this call. */ - newL2ToL1Messages: Fr[]; + newL2ToL1Messages: SideEffect[]; /** The new nullifiers to be inserted into the nullifier tree. */ - newNullifiers: Fr[]; + newNullifiers: SideEffectLinkedToNoteHash[]; /** The contract storage reads performed by the function. */ contractStorageReads: ContractStorageRead[]; /** The contract storage update requests performed by the function. */ diff --git a/yarn-project/acir-simulator/src/public/executor.ts b/yarn-project/acir-simulator/src/public/executor.ts index ca1451771dd8..84ddc89104f7 100644 --- a/yarn-project/acir-simulator/src/public/executor.ts +++ b/yarn-project/acir-simulator/src/public/executor.ts @@ -174,9 +174,9 @@ export class PublicExecutor { newNullifiers: newNullifiersPadded, } = extractPublicCircuitPublicInputs(partialWitness, acir); - const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isZero()); - const newCommitments = newCommitmentsPadded.filter(v => !v.isZero()); - const newNullifiers = newNullifiersPadded.filter(v => !v.isZero()); + const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isEmpty()); + const newCommitments = newCommitmentsPadded.filter(v => !v.isEmpty()); + const newNullifiers = newNullifiersPadded.filter(v => !v.isEmpty()); const [contractStorageReads, contractStorageUpdateRequests] = storageActions.collect(); this.log( @@ -222,6 +222,7 @@ export class PublicExecutor { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, // TODO(dbanks12): need to pass in the correct value here }); const nestedExecution: PublicExecution = { diff --git a/yarn-project/acir-simulator/src/public/index.test.ts b/yarn-project/acir-simulator/src/public/index.test.ts index 743cf6d3bdda..08f52f6ca166 100644 --- a/yarn-project/acir-simulator/src/public/index.test.ts +++ b/yarn-project/acir-simulator/src/public/index.test.ts @@ -74,6 +74,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); publicContracts.getBytecode.mockResolvedValue(Buffer.from(mintAbi.bytecode, 'base64')); @@ -122,6 +123,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); recipientStorageSlot = computeSlotForMapping(new Fr(1n), recipient.toField(), circuitsWasm); @@ -226,6 +228,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); // eslint-disable-next-line require-await @@ -294,6 +297,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); publicContracts.getBytecode.mockResolvedValue(Buffer.from(shieldAbi.bytecode, 'base64')); @@ -326,6 +330,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); publicContracts.getBytecode.mockResolvedValue(Buffer.from(createL2ToL1MessagePublicAbi.bytecode, 'base64')); @@ -378,6 +383,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); publicContracts.getBytecode.mockResolvedValue(Buffer.from(mintPublicAbi.bytecode, 'base64')); @@ -410,6 +416,7 @@ describe('ACIR public execution simulator', () => { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, + startSideEffectCounter: Fr.ZERO, }); publicContracts.getBytecode.mockResolvedValue(Buffer.from(createNullifierPublicAbi.bytecode, 'base64')); diff --git a/yarn-project/aztec-nr/aztec/src/context.nr b/yarn-project/aztec-nr/aztec/src/context.nr index 1bda3f8333b5..a85adf661f72 100644 --- a/yarn-project/aztec-nr/aztec/src/context.nr +++ b/yarn-project/aztec-nr/aztec/src/context.nr @@ -437,7 +437,6 @@ impl PrivateContext { end_side_effect_counter: self.side_effect_counter, }; self.public_call_stack.push(side_effect); - self.private_call_stack.push(side_effect); } } diff --git a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json index f6b9c62f5881..66bf5cd74841 100644 --- a/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json +++ b/yarn-project/aztec.js/src/abis/ecdsa_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "0000000200000800000000740000000f00000003515f3109623eb3c25aa5b16a1a79fd558bac7a7ce62c4560a8c537c77ce80dd339128d1d37b6582ee9e6df9567efb64313471dfa18f520f9ce53161b50dbf7731bc5f900000003515f322bc4cce83a486a92c92fd59bd84e0f92595baa639fc2ed86b00ffa0dfded2a092a669a3bdb7a273a015eda494457cc7ed5236f26cee330c290d45a33b9daa94800000003515f332729426c008c085a81bd34d8ef12dd31e80130339ef99d50013a89e4558eee6d0fa4ffe2ee7b7b62eb92608b2251ac31396a718f9b34978888789042b790a30100000003515f342be6b6824a913eb7a57b03cb1ee7bfb4de02f2f65fe8a4e97baa7766ddb353a82a8a25c49dc63778cd9fe96173f12a2bc77f3682f4c4448f98f1df82c75234a100000003515f351f85760d6ab567465aadc2f180af9eae3800e6958fec96aef53fd8a7b195d7c000c6267a0dd5cfc22b3fe804f53e266069c0e36f51885baec1e7e67650c62e170000000c515f41524954484d455449430d9d0f8ece2aa12012fa21e6e5c859e97bd5704e5c122064a66051294bc5e04213f61f54a0ebdf6fee4d4a6ecf693478191de0c2899bcd8e86a636c8d3eff43400000003515f43224a99d02c86336737c8dd5b746c40d2be6aead8393889a76a18d664029096e90f7fe81adcc92a74350eada9622ac453f49ebac24a066a1f83b394df54dfa0130000000c515f46495845445f42415345060e8a013ed289c2f9fd7473b04f6594b138ddb4b4cf6b901622a14088f04b8d2c83ff74fce56e3d5573b99c7b26d85d5046ce0c6559506acb7a675e7713eb3a00000007515f4c4f4749430721a91cb8da4b917e054f72147e1760cfe0ef3d45090ac0f4961d84ec1996961a25e787b26bd8b50b1a99450f77a424a83513c2b33af268cd253b0587ff50c700000003515f4d05dbd8623b8652511e1eb38d38887a69eceb082f807514f09e127237c5213b401b9325b48c6c225968002318095f89d0ef9cf629b2b7f0172e03bc39aacf6ed800000007515f52414e474504b57a3805e41df328f5ca9aefa40fad5917391543b7b65c6476e60b8f72e9ad07c92f3b3e11c8feae96dedc4b14a6226ef3201244f37cfc1ee5b96781f48d2b000000075349474d415f3125001d1954a18571eaa007144c5a567bb0d2be4def08a8be918b8c05e3b27d312c59ed41e09e144eab5de77ca89a2fd783be702a47c951d3112e3de02ce6e47c000000075349474d415f3223994e6a23618e60fa01c449a7ab88378709197e186d48d604bfb6931ffb15ad11c5ec7a0700570f80088fd5198ab5d5c227f2ad2a455a6edeec024156bb7beb000000075349474d415f3300cda5845f23468a13275d18bddae27c6bb189cf9aa95b6a03a0cb6688c7e8d829639b45cf8607c525cc400b55ebf90205f2f378626dc3406cc59b2d1b474fba000000075349474d415f342d299e7928496ea2d37f10b43afd6a80c90a33b483090d18069ffa275eedb2fc2f82121e8de43dc036d99b478b6227ceef34248939987a19011f065d8b5cef5c0000000010000000000000000100000002000000030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f" }, { @@ -84,7 +84,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -147,7 +147,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -164,7 +164,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "0000000200000800000000740000000f00000003515f3109623eb3c25aa5b16a1a79fd558bac7a7ce62c4560a8c537c77ce80dd339128d1d37b6582ee9e6df9567efb64313471dfa18f520f9ce53161b50dbf7731bc5f900000003515f322bc4cce83a486a92c92fd59bd84e0f92595baa639fc2ed86b00ffa0dfded2a092a669a3bdb7a273a015eda494457cc7ed5236f26cee330c290d45a33b9daa94800000003515f332729426c008c085a81bd34d8ef12dd31e80130339ef99d50013a89e4558eee6d0fa4ffe2ee7b7b62eb92608b2251ac31396a718f9b34978888789042b790a30100000003515f342be6b6824a913eb7a57b03cb1ee7bfb4de02f2f65fe8a4e97baa7766ddb353a82a8a25c49dc63778cd9fe96173f12a2bc77f3682f4c4448f98f1df82c75234a100000003515f351f85760d6ab567465aadc2f180af9eae3800e6958fec96aef53fd8a7b195d7c000c6267a0dd5cfc22b3fe804f53e266069c0e36f51885baec1e7e67650c62e170000000c515f41524954484d455449430d9d0f8ece2aa12012fa21e6e5c859e97bd5704e5c122064a66051294bc5e04213f61f54a0ebdf6fee4d4a6ecf693478191de0c2899bcd8e86a636c8d3eff43400000003515f43224a99d02c86336737c8dd5b746c40d2be6aead8393889a76a18d664029096e90f7fe81adcc92a74350eada9622ac453f49ebac24a066a1f83b394df54dfa0130000000c515f46495845445f42415345060e8a013ed289c2f9fd7473b04f6594b138ddb4b4cf6b901622a14088f04b8d2c83ff74fce56e3d5573b99c7b26d85d5046ce0c6559506acb7a675e7713eb3a00000007515f4c4f4749430721a91cb8da4b917e054f72147e1760cfe0ef3d45090ac0f4961d84ec1996961a25e787b26bd8b50b1a99450f77a424a83513c2b33af268cd253b0587ff50c700000003515f4d05dbd8623b8652511e1eb38d38887a69eceb082f807514f09e127237c5213b401b9325b48c6c225968002318095f89d0ef9cf629b2b7f0172e03bc39aacf6ed800000007515f52414e474504b57a3805e41df328f5ca9aefa40fad5917391543b7b65c6476e60b8f72e9ad07c92f3b3e11c8feae96dedc4b14a6226ef3201244f37cfc1ee5b96781f48d2b000000075349474d415f3125001d1954a18571eaa007144c5a567bb0d2be4def08a8be918b8c05e3b27d312c59ed41e09e144eab5de77ca89a2fd783be702a47c951d3112e3de02ce6e47c000000075349474d415f3223994e6a23618e60fa01c449a7ab88378709197e186d48d604bfb6931ffb15ad11c5ec7a0700570f80088fd5198ab5d5c227f2ad2a455a6edeec024156bb7beb000000075349474d415f3300cda5845f23468a13275d18bddae27c6bb189cf9aa95b6a03a0cb6688c7e8d829639b45cf8607c525cc400b55ebf90205f2f378626dc3406cc59b2d1b474fba000000075349474d415f342d299e7928496ea2d37f10b43afd6a80c90a33b483090d18069ffa275eedb2fc2f82121e8de43dc036d99b478b6227ceef34248939987a19011f065d8b5cef5c0000000010000000000000000100000002000000030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f" }, { @@ -226,6 +226,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -272,6 +278,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -297,6 +309,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -308,7 +326,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -318,7 +357,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -328,7 +382,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -338,7 +413,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -418,7 +508,7 @@ ] } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -487,6 +577,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -533,6 +629,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -558,6 +660,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -569,7 +677,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -579,7 +708,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -589,7 +733,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -599,7 +764,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -679,7 +859,7 @@ ] } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" } ] diff --git a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json index a1e4f3798428..89a9de61a246 100644 --- a/yarn-project/aztec.js/src/abis/schnorr_account_contract.json +++ b/yarn-project/aztec.js/src/abis/schnorr_account_contract.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -72,7 +72,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -135,7 +135,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -152,7 +152,7 @@ } ], "returnTypes": [], - "bytecode": "H4sIAAAAAAAA/+2dB5gUxdPG52450pFzzlEQbrmDu1PRAxElIyCgYCCqqKCCCVEwoIiKijnnnHPAnHPOWTFgFrOo+E0d3VA7rHzyv7farufpeZ6hZ2eX7reqprvqtzu7t6xyFFWvFpVvOfGeG++VzLF9nJd4XNkc880+LjNtYUGfoqJpxb2mpQvTkwp6lU4u6V1Q1Htyn5J0Sbp3Se+pvUoKC6eVFJUUl04uLS4oTRcVTktP711aOL1gzdaY9VVQwU1SZxMlOpsq0dlMic7mSnS2UKKzpRKdrZTobK1EZxslOtsq0dlOic72SnR2UKKzoxKdnZTo7KxEZxclOrsq0bmJEp3dlOjsrkTnpkp09lCis6cSnQVKdKaV6OylRGehEp1FSnT2BuokbfQeYxvTX6N4Xx3vjU3bxLRNTdvMtM1N28K0LU3byrStTdvGtG1N28607U3bwbQdTdvJtJ1N28W0XU27iWm7mba7aTc1bQ/T9jRtgWnTpu1l2kLTFpm2N+uvT7wXR2vei6Ut17T2vGRsSyId12CpEp2bKdG5uRKdWyjR2VeJzi2V6NxKic4yJTr7KdHZX4nOrZXoHKBE5zZKdA6M8LVwHdMf1XtUE5aYttS0m5l2c9NuYdq+pt3StFuZtsy0/Uzb37Rbm3aAabcx7cBoXS26bbxvF627L8DWovZ8Kt6rRP+8lWF8k5bru1exYN8lgn2XCvY9SbDvyYJ9T6nM+hxk2sGmHWLaoaYdZtrh7P8cmVrT0m0yVc052yeds9d6Hjtnn6/EztnnU+ycfT6XnbPP57Bz9vkoMT5tZaYtqODG7+tB9Uk212V2RFnszcnil9ws/rPP52XxH4+Hfd7GpZZ5vpqAv/LBfZLG6lHmlrzXqowd5zP7awjYV1PAvhobYV9NZl8tAftqC9hXayPsq83sqyNgX10B++pshH11mX31BOwD95mmPusL6GyI7bOY4tAg+vdxaMji0EjAvsbgPqmPJky/tdVqz2fPN2a2NcHqSOewMW2/9nETuXHL7W/6/9jfNIuOpg7tbxrsD/YH+4P9wX7wuOny/M7HpW1D+Z1raQbVsia/S8S3OdNvbbXa89nzPL7NsTrK49ssyvSpfdycjRvsh44b7I+C/cH+YH+wP9gf7A/2B/uD/cH+YH+wP9gf7A/2B/uD/cH+YL8P9uez53OZFvD77OkNvb/fLIuWlEdaKnmkJc8jLZU90lLFIy1VPdJSzSMt1T3Sku+RlhoeaanpkZZaHmmp7ZGWOh5pqeuRlnoeaanvkZYGHmlp6JGWRh5paeyRliYeaRG892ejteT8x1r490kids4+n8vOWb7j3ztpYY75905ammP+vZNWzE57rrU5rsLOtTHHVdm5tuzYtu3McXV2rr05rsHOdTDHtdi5jua4DjvXyRzXY+c6m+P67FwXc9yAnetqjhuxc9Zv3M/Wb83ZOeu3Fuyc9VtLds76rRU7Z/3Wmp2zfmvDzlm/cT9av7Vj5+x12Z6ds77swM7Zeq4jO2f924mds/VNZ3bO+rwLO2fzvfUj2X9pzrrn7Wv5tdg1Sz/2mM8pO3aZaQsqtpXPKT5OGXtsx6rONHTxQEtTj7Q08UhLY4+0NPJIS0OPtDTwSEt9j7TU80hLXY+01PFIS22PtNTySEtNj7TU8EhLvkdaqnukpZpHWqp6pKWKR1oqe6QlzyMtlTzSkvJIS24WLRKfmVsepc0yYxOmw2rqxHR0BPuE+uiQRUdHpsOO34HpaI/VQT+buZb3uY72TIcdvx3T0Rarg362c+37E1xHW6bDjt+G6WiN1UE/G7r2/RSuozXTYcfn71+1xOqgny1d+/4P19GS6bDjt2A6wPd29KE+mmXR0ZzpsOM3Yzo2werIuMfE/maWnad2rBR7zRnmzRaqK/l7l/y9qG7mmL+P1d0c8/fANjXHbdi5HuaYv/fW0xzz9+029J5fN3bO5oTu7JzNWZuyczan9mDnbM6341cxrwP/BkcvGssypt1yEo/L2DF/j9QyO//sDPx7HuXXSIOEFvvYjpXPNNSR01Kc/w9j243fA9VAwA9Rwg92a5BFS8ojLZU80pLnkZbKHmmp4pGWqh5pqeaRluoeacn3SEsNj7TU9EhLLY+01PZISx2PtNT1SEs9j7TU90hLzn+s5Z/u3bDP88/LG7Jj29rPHPk9FI0TdtI5+34Jv6/CfqZck52z3MPvtbDsWJuds8zEf+c0N4tttlbl2m3NyO+1sLVbY3bO1lBN2DlbyzRl52xNwZnN+ojfp2F9ZLXTmHNT69uZm8VO3o89lr7vh49Txh7bsfg9Cs090FLfIy31PNJS1yMtdTzSUtsjLbU80lLTIy01PNKS75GW6h5pqeaRlqoeaanikZbKHmnJ80hLJY+0pDzSkptFC/h3Ptf7vWlb6zZlOqwmfu8/+nevcxI62rBx+fcfwL/hXf6ZbsMs9nOmsuM3FIwDZzvbN82Lslw52wU+iy2Po/28k7b5zK7WzH8S47ZKjNsoMS7/rKmyeY3Vav9vir1maO66OGxnjquz/vh3DNokxuIsbJ+zn/G1FbDdjmHHsz5vy2xvy2xvw/5PE2a7fc32zPZxqXX/D3wvQ/ln5vZz21ymuz3TCr6Po/z+CX4fh+2/HTvXmR3bNcH+H36fR2emU2Jt4jrs+Pz3kbtm0cnvz+mSeJ3A5/zl1x/Xwe8d4p/z29fsyq6tsezakojzJtH6/uvIfNEdPCa/R4H7g29l7Lg709IDq6WQ3wfxb7T0YFp6YrUUSNUu/A/aWVut9nz2PP+uYAFWR3k91zPK9Kl9XMDGDfZDx1VlP7/XqNt/rCWfadhUTkthfuTmOuC+5bXzAlY7p8G2UZ9FYDsodr2iddt8ZlcR85/EuIWJcdOJcXMSMZzPtNr/m2KvmZBaF4dFrHa2/fE5ILEu9InWbXZMzrS9zXEfpkOifivOooOzpR2/mOmQqINKsujg9y3b8UuYjlKwjmoJHbRtqB4pZVo2F9Cy2UZo2Zxp6SugZYuN0NKXadlKQMuWG6FlK6aln4CWso3Q0o9p2VpAS/+N0GLHp/83wBzzubUNVl953h+Q0GIf27HymYbeglrys4zN/bCZB36wGvr8h37YwgM/WA3F/6EftvTAD1ZD4//QD2Ue+MGO1+k/9EN/D/xgNeQ69kN1do7frzcQO3YxH5O/7zqQjbkt2F7qcxDYDrputosytw3l5UHMviFYLeUcNZT1X8bG4OMOA/uVj5tjdjuGPZ9ix+/Yi5q9jjZ73VnNdC0OzvI6frxd4v/ks+cHC9s8hOkoY4/tWMSeLzJbB2fRzee8fX5bpluCCQcxHXZ8/ntz4OuyfI5w22nb0BwZwrSA41Y+R4az/svYGHzcEWC/83HtHLFj2PMpdvwtu25GrDtce91YzTRHhmZ5HT9OzqF89vxQYZv5XC1jj+1YNEeWM1uHZtE9iOm2z3N+kJgjfG7b8fkcAV+X5XOE207bhubIMKYFHLfyOTKS9V/GxuDjbg/2Ox/XzhE7hj2f4q+xN8uw19FmrxurmebI8Cyv48fJOZTPnh8ubDOfq2XssR2L5sgvbI4Mz6Kb5z/7vPR7i3xu2/H5HAFfl+VzhNtO24bmyAimBRy38jkyivVfxsbg444G+52Pa+eIHcOeT7HjBmyOjF53uPa6sZppjozM8jp+nJxD+ez5kcI287laxh7bsWiOVGO2jsyim+c/+zx/30FijvC5bcfncwR8XZbPEW47bRuaI9szLeC4lc+RMaz/MjYGH3cHsN/5uHaO2DHs+RQ77syumx3WHa69bqxmmiOjsryOHyfnUD57fpSwzXyulrHHdiyaIy2YraOy6Ob5zz4vff8jn9t2fD5HwNdl+RzhttO2oTkymmkBx618joxl/ZexMfi448B+5+PaOWLHsOdT7Hgzdt2MW3e49rqxmmmOjMnyOn6cnEP57PkxwjbzuVrGHtuxaI70ZLaOyaKb5z/7PH+/UmKO8Lltx+dzBHxdls8RbjttG5ojOzAt4LiVz5HxrP8yNgYfd0ew3/m4do7YMez5FDsexq6bHdcdrr1urGaaI2OzvI4fJ+dQPnt+rLDNfK6Wscd2LJoj/ZmtY7Po5vnPPm8Rhq4tGzf+HvNYAVv+ab6PZfrqJbQLaCnOzzI2v/80eZ+zxBrCfWHfb+fff7bneL1Qxu6dsbq7sX74tWLvFeL3vPJrukXi/1Cf4xOvI9t3wtpefh8q10HbhtaynZiWiVgt5WvZzqz/MjYGH3cX7LhpPq5dy+wY9nyKHc9k83uXdYdrrwGrmWI4Icvr+PGOif+Tz56fIGzzRKajjD22Y9E1PoXZOiGLbn4/p32e5yOJuboT02HH53PV6uD3sYGv1XL/TUj4zz7mseyW8JeAlsL8LGPz+y6tv5L3XeZDdaSLqc+a4D7538ew24bWJzt+1Wjdd113nzZn+Kw502bnsP9v+7T8Vp31kcuOU+z/VIrW15GX5VzlLOeqROtvVdlxNXacz/5f9YRO/ndA+G+FWM32uSrR+n6CTkK75Sb6LizoU1Q0rbjXtHRhelJBr9LJJb0LinpP7lOSLkn3Luk9tVdJYeG0kqKS4tLJpcUFpemiwmnp6b1LC6ebznOBOofi+uL3sq91LErncKD/UlGWwAtoHhZhE7/d+JuClRLXGG38xxXRNkWJcZJ+rBUJTyqJII0Q6HdkhLtgpeweiY9RgV3d7UVIn36ujtZ8qkbtENPSRu9EEN1ShsiN1l3E9jzfkvZX1KejI2ylU5npH21s3J7ZSnS4g7E1xV5rz2+M36iKHmf6qsT6sucl/TZe0G/jjY1jma1UFe5kbM1jr7Xnk33kmv+7o2nJP1T5TTT/n7/Wnk/2Mcz83wmmtWSzi+mjCnutPc83dMJHriW7AuPnKpE2ivCJNIf1uVu8T4r3yfE+Jd6nxvu0eJ8e77vH+x7xvme8z4j3veJ973jfJ95nxvuseN833veL9/3jfXa8z4n3A+L9wHg/KN4PjvdD4n1uvB8a7/Pi/bB4Pzxa802kBfF+RLwfGe9HxfvR8b4w3o+J92PjfVG8Hxfvi+P9+Hg/Id5PjPcl8X5SvJ8c76fE+9J4PzXeT4v30+P9jHg/M97Pivez4/2ceD833s+L9/Pj/YJ4vzBat/Ff0eMFBW28Yi+LMLEQKFAK8phWTgy8+qfnK0HHLSrgvxRotw1RmB2/arSOSGIK63fAnD3G7Tln5rTZGSyWSvSQk8Uy/huE/G9j2uftc6Lck2dMsv3tFoWpZTd0Kr4I0Ne06bS5W8ovivBLOW0Xs+PARBXs8yLjUHS/l0R+MxHZfQk+RqJvjFwC1JmK1s9hEpp3E/ItNG5pwb7j3vnidKlpL2PnbO3Cubgyi4eNEy12f0frxyqHHeea16Q28Jqcf+iH11D2/9saKsL6RKQeFF18c4xzKYC/mIHoMQWyamJMNBReCuzr8gyfVKw3V5XE5ZFMJXEFOw6VRAX7vNw4FN3vlZHflQTZfSU+Rlm1VtT+y4xWdL9XRdgJSpOQ+uQZibYUOHa7AXxgsQq5SF8Gvo7sho771UD/uUomV0cyyeQadhySSQX7vNo4FN3vtZHfyYTsvhYfI1EsvRao0xWWThLyLTRuDrH0OtNez84FLMX06QRLKYAcSymQ0lh6HbCvGyJ9WHpDJFNJ3MiOQyVRwT5vMA5F93tT5HclQXbfhI+RCJZeb7Si+705wk5QmoTUpzSWTgL4wGIVcpG+Hnwd2Q0d91uA/nOVTG6JZJLJrew4JJMK9nmLcSi639siv5MJ2X0bPkaiWHobUKcrLJ0s5Fto3Bxi6e2mvYOdC1iK6dMJllIAOZZSIKWx9HZgX3dG+rD0zkimkriLHYdKooJ93mkciu737sjvSoLsvhsfIxEsvcNoRfd7T4SdoDQJqU9pLJ0M8IHFKuQifQf4OrIbOu7LgP5zlUyWRTLJ5F52HJJJBftcZhyK7ve+yO9kQnbfh4+RKJbeB9TpCkunCPkWGjeHWHq/aR9g5wKWYvp0gqUUQI6lFEhpLL0f2NeDkT4sfTCSqSQeYsehkqhgnw8ah6L7fTjyu5Igux/Gx0gESx8wWtH9PhJhJyhNQupTGkunAHxgsQq5SD8Avo7sho77o0D/uUomj0YyyeQxdhySSQX7fNQ4FN3v45HfyYTsfhwfI1EsfRyo0xWWThXyLTRuDrH0CdM+yc4FLMX06QRLKYAcSymQ0lj6BLCvpyJ9WPpUJFNJPM2OQyVRwT6fMg5F9/tM5HclQXY/g4+RCJY+abSi+302wk5QmoTUpzSWTgX4wGIVcpF+Enwd2Q0d9+eA/nOVTJ6LZJLJ8+w4JJMK9vmccSi63xciv5MJ2f0CPkaiWPoCUKcrLJ0m5Fto3Bxi6YumfYmdC1iK6dMJllIAOZZSIKWx9EVgXy9H+rD05UimkniFHYdKooJ9vmwciu731cjvSoLsfhUfIxEsfcloRff7WoSdoDQJqU9pLJ0G8IHFKuQi/RL4OrIbOu6vA/3nKpm8HskkkzfYcUgmFezzdeNQdL9vRn4nE7L7TXyMRLH0TaBOV1g6Xci30Lg5xNK3TPs2OxewFNOnEyylAHIspUBKY+lbwL7eifRh6TuRTCXxLjsOlUQF+3zHOBTd73uR35UE2f0ePkYiWPq20Yru9/0IO0FpElKf0lg6HeADi1XIRfpt8HVkN3TcPwD6z1Uy+SCSSSYfsuOQTCrY5wfGoeh+P4r8TiZk90f4GIli6UdAna6wdHch30Lj5hBLPzbtcnYuYCmmTydYSgHkWEqBlMbSj4F9fRLpw9JPIplK4lN2HCqJCvb5iXEout/PIr8rCbL7M3yMRLB0udGK7vfzCDtBaRJSn9JYujvABxarkIv0cvB1ZDd03FcA/ecqmayIZJLJF+w4JJMK9rnCOBTd75eR38mE7P4SHyNRLP0SqNMVlu4h5Fto3Bxi6Vem/ZqdC1iK6dMJllIAOZZSIKWx9CtgX99E+rD0m0imkviWHYdKooJ9fmMciu73u8jvSoLs/g4fIxEs/dpoRff7fYSdoDQJqU9pLN0D4AOLVchF+mvwdWQ3dNxXAv3nKpmsjGSSyQ/sOCSTCva50jgU3e+Pkd/JhOz+ER8jUSz9EajTFZbuKeRbaNwcYulPpv2ZnQtYiunTCZZSADmWUiClsfQnYF+/RPqw9JdIppL4lR2HSqKCff5iHIru97fI70qC7P4NHyMRLP3ZaEX3+3uEnaA0CalPaSzdE+ADi1XIRfpn8HVkN3TcVwH95yqZrIpkkskf7Dgkkwr2uco4FN3vn5HfyYTs/hMfI1Es/ROo0xWWzhDyLTRuDrH0L9OuZucClmL6dIKlFECOpRRIaSz9C9jX35E+LP07kqkkuPhQSVSwz79Np+h+c3L8riTI7pwceIxEsHS10YruNzcHj6XUpzSWzgD4wGIVcpFeHWGvI7uh457KwfnPVTJJ5cgkk0ohmWCDVEkgmeR5nkzI7jyhZGI3SZ8WVHBzhaV7RTK+hcbNIZZWNg6uwq69gKWYPp1gKQWQYykFUhpLKwMX06o5+rC0qlAlUS1UEtggVROoJKp7XkmQ3dWVYGkVoxXdb74AluY7wNK9AD6wWIVcpKvkYK8ju6HjXkMhltYQSiY1QzLBBqmmQDKp5XkyIbtrKcPSWgqxdO9IxrfQuDnE0trGwXUClurE0toJLK3jAEtrAxfTugqxtK5QJVEvVBLYINUTqCTqe15JkN31lWBpHaMV3W8DASxt4ABL9wb4wGIVcpGuowRLGyrE0oZCyaRRSCbYIDUSSCaNPU8mZHdjZVjaWCGW7hPJ+BYaN4dY2sQ4uGnAUp1Y2iSBpU0dYGkT4GLaTCGWNhOqJJqHSgIbpOYClUQLzysJsruFEixtarSi+20pgKUtHWDpPgAfWKxCLtJNlWBpK4VY2koombQOyQQbpNYCyaSN58mE7G6jDEvbKMTSmZGMb6Fxc4ilbY2D2wUs1YmlbRNY2s4BlrYFLqbtFWJpe6FKokOoJLBB6iBQSXT0vJIguzsqwdJ2Riu6304CWNrJAZbOBPjAYhVykW6nBEs7K8TSzkLJpEtIJtggdRFIJl09TyZkd1dlWNpVIZbOimR8C42bQyzdxDi4W8BSnVi6SQJLuznA0k2Ai2l3hVjaXaiS2DRUEtggbSpQSfTwvJIgu3sowdJuRiu6354CWNrTAZbOAvjAYhVyke6mBEsLFGJpgVAySYdkgg1SWiCZ9PI8mZDdvZRhaS+FWLpvJONbaNwcYmmhcXBRwFKdWFqYwNIiB1haCFxMeyvE0t5ClUSfUElgg9RHoJIo9rySILuLlWBpkdGK7rdEAEtLHGDpvgAfWKxCLtJFSrC0VCGWlgolk81CMsEGaTOBZLK558mE7N5cGZZurhBL94tkfAuNm0Ms3cI4uG/AUp1YukUCS/s6wNItgIvplgqxdEuhSmKrUElgg7SVQCVR5nklUX5xKsHSvkYrut9+AljazwGW7gfwgcUq5CLdVwmW9leIpf2FksnWIZlgg7S1QDIZ4HkyIbsHKMPSAQqxdP9IxrfQuDnE0m2MgwcGLNWJpdsksHSgAyzdBriYbqsQS7cVqiS2C5UENkjbCVQSgzyvJMjuQUqwdKDRiu53sACWDnaApfsDfGCxCrlID1SCpUMUYukQoWQyNCQTbJCGCiSTYZ4nE7J7mDIsHaYQS2dHMr6Fxs0hlg43Dh4RsFQnlg5PYOkIB1g6HLiYjlSIpSOFKontQyWBDdL2ApXEKM8rCbJ7lBIsHWG0ovsdLYClox1g6WyADyxWIRfpEUqwdIxCLB0jlEx2CMkEG6QdBJLJWM+TCdk9VhmWjlWIpXMiGd9C4+YQS8cZB48PWKoTS8clsHS8AywdB1xMd1SIpTsKVRI7hUoCG6SdBCqJCZ5XEmT3BCVYOt5oRfc7UQBLJzrA0jkAH1isQi7S45Vg6c4KsXRnoWSyS0gm2CCRQ9H97prjdzIhu3fNgcdIFEu5TwsquLnC0gMiGd9C4+YQS3czDp7Err2ApZg+nWApBZBjKQVSGkt3Ay6mk3P0YenkHJlKYgp7ECqJCvZJQZoiUElM9bySILunClUSSa0VtX+S0Yrudxp4gtIkpD6lsfQAgA8sViEX6Uk52OvIbui4T8/B+c9VMpkulEx2D8kEG6TdBZLJHp4nE7J7D2VYuodCLD0wkvEtNG4OsXRP4+AZAUt1YumeCSyd4QBL9wQupnspxNK9hCqJvUMlgQ3S3gKVxD6eVxJk9z5KsHSG0Yrud6YAls50gKUHAnxgsQq5SM9QgqWzFGLpLKFksm9IJtgg7SuQTPbzPJmQ3fspw9L9FGLpQZGMb6Fxc4il+xsHzw5YqhNL909g6WwHWLo/cDGdoxBL5whVEgeESgIbpAMEKokDPa8kyO4DlWDpbKMV3e9BAlh6kAMsPQjgA4tVyEV6thIsPVghlh4slEwOCckEG6RDBJLJXM+TCdk9VxmWzlWIpQdHMr6Fxs0hlh5qHDwvYKlOLD00gaXzHGDpocDF9DCFWHqYUCVxeKgksEE6XKCSmO95JUF2z1eCpfOMVnS/CwSwdIEDLD0Y4AOLVchFep4SLD1CIZYeIZRMjgzJBBukIwWSyVGeJxOy+yhlWHqUQiw9JJLxLTRuDrH0aOPghQFLdWLp0QksXegAS48GLqbHKMTSY4QqiWNDJYEN0rEClcQizysJsnuREixdaLSi+z1OAEuPc4ClhwB8YLEKuUgvVIKlixVi6WKhZHJ8SCbYIB0vkExO8DyZkN0nKMPSExRi6dxIxrfQuDnE0hONg5cELNWJpScmsHSJAyw9EbiYnqQQS08SqiRODpUENkgnC1QSp3heSZDdpyjB0iVGK7rfpQJYutQBls4F+MBiFXKRXqIES09ViKWnCiWT00IywQbpNIFkcrrnyYTsPl0Zlp6uEEsPjWR8C42bQyw9wzj4zIClOrH0jASWnukAS88ALqZnKcTSs4QqibNDJYEN0tkClcQ5nlcSZPc5SrD0TKMV3e+5Alh6rgMsPRTgA4tVyEX6TCVYep5CLD1PKJmcH5IJNkjnCySTCzxPJmT3Bcqw9AKFWDovkvEtNG4OsfRC4+CLApbqxNILE1h6kQMsvRC4mF6sEEsvFqokLgmVBDZIlwhUEpd6XkmQ3ZcqwdKLjFZ0v5cJYOllDrB0HsAHFquQi/RFSrD0coVYerlQMrkiJBNskK4QSCZXep5MyO4rlWHplQqx9LBIxrfQuDnE0quMg68OWKoTS69KYOnVDrD0KuBieo1CLL1GqJK4NlQS2CBdK1BJXOd5JUF2X6cES682WtH9Xi+Apdc7wNLDAD6wWIVcpK9WgqU3KMTSG4SSyY0hmWCDdKNAMrnJ82RCdt+kDEtvUoilh0cyvoXGzSGW3mwcfEvAUp1YenMCS29xgKU3AxfTWxVi6a1ClcRtoZLABuk2gUrids8rCbL7diVYeovRiu73DgEsvcMBlh4O8IHFKuQifYsSLL1TIZbeKZRM7grJBBukuwSSyd2eJxOy+25lWHq3QiydH8n4Fho3h1h6j3HwsoClOrH0ngSWLnOApfcAF9N7FWLpvUKVxH2hksAG6T6BSuJ+zysJsvt+JVi6zGhF9/uAAJY+4ABL5wN8YLEKuUgvU4KlDyrE0geFkslDIZlgg/SQQDJ52PNkQnY/rAxLH1aIpQsiGd9C4+YQSx8xDn40YKlOLH0kgaWPOsDSR4CL6WMKsfQxoUri8VBJYIP0uEAl8YTnlQTZ/YQSLH3UaEX3+6QAlj7pAEsXAHxgsQq5SD+qBEufUoilTwklk6dDMsEG6WmBZPKM58mE7H5GGZY+oxBLj4hkfAuNm0MsfdY4+LmApTqx9NkElj7nAEufBS6mzyvE0ueFKokXQiWBDdILApXEi55XEmT3i0qw9DmjFd3vSwJY+pIDLD0C4AOLVchF+jklWPqyQix9WSiZvBKSCTZIrwgkk1c9TyZk96vKsPRVhVh6ZCTjW2jcHGLpa8bBrwcs1YmlryWw9HUHWPoacDF9QyGWviFUSbwZKglskN4UqCTe8rySILvfUoKlrxut6H7fFsDStx1g6ZEAH1isQi7SryvB0ncUYuk7Qsnk3ZBMsEF6VyCZvOd5MiG731OGpe8pxNKjIhnfQuPmEEvfNw7+IGCpTix9P4GlHzjA0veBi+mHCrH0Q6FK4qNQSWCD9JFAJfGx55UE2f2xEiz9wGhF97tcAEuXO8DSowA+sFiFXKQ/UIKlnyjE0k+EksmnIZlgg/SpQDL5zPNkQnZ/pgxLP1OIpUdHMr6Fxs0hln5uHLwiYKlOLP08gaUrHGDp58DF9AuFWPqFUCXxZagksEH6UqCS+MrzSoLs/koJlq4wWtH9fi2ApV87wNKjAT6wWIVcpFcowdJvFGLpN0LJ5NuQTLBB+lYgmXzneTIhu79ThqXfKcTShZGMb6Fxc4il3xsHrwxYqhNLv09g6UoHWPo9cDH9QSGW/iBUSfwYKglskH4UqCR+8rySILt/UoKlK41WdL8/C2Dpzw6wdCHABxarkIv0SiVY+otCLP1FKJn8GpIJNki/CiST3zxPJmT3b8qw9DeFWHpMJONbaNwcYunvxsGrApbqxNLfE1i6ygGW/g5cTP9QiKV/CFUSf4ZKAhukPwUqib88ryTI7r+UYOkqoxXd72oBLF3tAEuPAfjAYhVykV6lBEv/VoilfwslE545QjKpYJ9/m1UA3W9Ort/JhOzOyYXHSBRLuU8LKri5wtJjIxnfQuPmEEtzzYMUOxmwFNOnEyylAHIspUBKY2kucDGtlKsPSyvlylQSeaGSwAYpT6CSqOx5JUF2VxaqJNAYkTJa0f1WAU9Qcif1KY2lxwJ8YLEKuUincrHXkd3Qca+ai/Ofq2RSVSiZVAvJBBukagLJpLrnyYTsrq4MS6srxNJFkYxvoXFziKX55kGNgKU6sTQ/gaU1HGBpPnAxrakQS2sKVRK1QiWBDVItgUqitueVBNldWwmW1jBa0f3WEcDSOg6wdBHABxarkIt0DSVYWlchltYVSib1QjLBBqmeQDKp73kyIbvrK8PS+gqx9LhIxrfQuDnE0gbmQcOApTqxtEECSxs6wNIGwMW0kUIsbSRUSTQOlQQ2SI0FKokmnlcSZHcTJVja0GhF99tUAEubOsDS4wA+sFiFXKQbKsHSZgqxtJlQMmkekgk2SM0FkkkLz5MJ2d1CGZa2UIiliyMZ30Lj5hBLW5oHrQKW6sTSlgksbeUAS1sCF9PWCrG0tVAl0SZUEtggtRGoJNp6XkmQ3W2VYGkroxXdbzsBLG3nAEsXA3xgsQq5SLdSgqXtFWJpe6Fk0iEkE2yQOggkk46eJxOyu6MyLO2oEEuPj2R8C42bQyztZB50DliqE0s7JbC0swMs7QRcTLsoxNIuQpVE11BJYIPUVaCS2MTzSoLs3kQJlnY2WtH9dhPA0m4OsPR4gA8sViEX6c5KsLS7QiztLpRMNg3JBBukTQWSSQ/PkwnZ3UMZlvZQiKUnRDK+hcbNIZb2NA8KApbqxNKeCSwtcIClPYGLaVohlqaFKoleoZLABqmXQCVR6HklQXYXKsHSAqMV3W+RAJYWOcDSEwA+sFiFXKQLlGBpb4VY2lsomfQJyQQbpD4CyaTY82RCdhcrw9JihVh6YiTjW2jcHGJpiXlQGrBUJ5aWJLC01AGWlgAX080UYulmQpXE5qGSwAZpc4FKYgvPKwmyewslWFpqtKL77SuApX0dYOmJAB9YrEIu0qVKsHRLhVi6pVAy2SokE2yQthJIJmWeJ5Pyi1MZlpYpxNIlkYxvoXFziKX9zIP+AUt1Ymm/BJb2d4Cl/YCL6dYKsXRroUpiQKgksEEaIFBJbON5JUF2b6MES/sbreh+Bwpg6UAHWLoE4AOLVchFur8SLN1WIZZuK5RMtgvJBBuk7QSSySDPkwnZPUgZlg5SiKUnRTK+hcbNIZYONg+GBCzViaWDE1g6xAGWDgYupkMVYulQoUpiWKgksEEaJlBJDPe8kiC7hyvB0iFGK7rfEQJYOsIBlp4E8IHFKuQiPUQJlo5UiKUjhZLJ9iGZYIO0vUAyGeV5MiG7RynD0lEKsfTkSMa30Lg5xNLR5sGYgKU6sXR0AkvHOMDS0cDFdAeFWLqDUCUxNlQS2CCNFagkxnleSZDd45Rg6RijFd3veAEsHe8AS08G+MBiFXKRHqMES3dUiKU7CiWTnUIywQZpJ4FkMsHzZEJ2T1CGpRMUYukpkYxvoXFziKUTzYOdA5bqxNKJCSzd2QGWTgQuprsoxNJdhCqJXUMlgQ3SrgKVxG6eVxJk925KsHRnoxXd7yQBLJ3kAEtPAfjAYhVykd5ZCZZOVoilk4WSyZSQTLBBmiKQTKZ6nkzI7qnKsHSqQixdGsn4Fho3h1g6zTyYHrBUJ5ZOS2DpdAdYOg24mO6uEEt3F6ok9giVBDZIewhUEnt6XkmQ3XsqwdLpRiu63xkCWDrDAZYuBfjAYhVykZ6uBEv3Uoilewklk71DMsEGaW+BZLKP58mE7N5HGZbuoxBLT41kfAuNm0MsnWkezApYqhNLZyawdJYDLJ0JXEz3VYil+wpVEvuFSgIbpP0EKon9Pa8kyO79lWDpLKMV3e9sASyd7QBLTwX4wGIVcpGepQRL5yjE0jlCyeSAkEywQTpAIJkc6HkyIbsPVIalByrE0tMiGd9C4+YQSw8yDw4OWKoTSw9KYOnBDrD0IOBieohCLD1EqJKYGyoJbJDmClQSh3peSZDdhyrB0oONVnS/8wSwdJ4DLD0N4AOLVchF+mAlWHqYQiw9TCiZHB6SCTZIhwskk/meJxOye74yLJ2vEEtPj2R8C42bQyxdYB4cEbBUJ5YuSGDpEQ6wdAFwMT1SIZYeKVRJHBUqCWyQjhKoJI72vJIgu49WgqVHGK3ofhcKYOlCB1h6OsAHFquQi/QRSrD0GIVYeoxQMjk2JBNskI4VSCaLPE8mZPciZVi6SCGWnhHJ+BYaN4dYepx5sDhgqU4sPS6BpYsdYOlxwMX0eIVYerxQJXFCqCSwQTpBoJI40fNKguw+UQmWLjZa0f0uEcDSJQ6w9AyADyxWIRfpxUqw9CSFWHqSUDI5OSQTbJBOFkgmp3ieTMjuU5Rh6SkKsfTMSMa30Lg5xNKl5sGpAUt1YunSBJae6gBLlwIX09MUYulpQpXE6aGSwAbpdIFK4gzPKwmy+wwlWHqq0Yru90wBLD3TAZaeCfCBxSrkIn2qEiw9SyGWniWUTM4OyQQbpLMFksk5nicTsvscZVh6jkIsPSuS8S00bg6x9Fzz4LyApTqx9NwElp7nAEvPBS6m5yvE0vOFKokLQiWBDdIFApXEhZ5XEmT3hUqw9DyjFd3vRQJYepEDLD0L4AOLVchF+jwlWHqxQiy9WCiZXBKSCTZIlwgkk0s9TyZk96XKsPRShVh6diTjW2jcHGLpZebB5QFLdWLpZQksvdwBll4GXEyvUIilVwhVEleGSgIbpCsFKomrPK8kyO6rlGDp5UYrut+rBbD0agdYejbABxarkIv05Uqw9BqFWHqNUDK5NiQTbJCuFUgm13meTMju65Rh6XUKsfScSMa30Lg5xNLrzYMbApbqxNLrE1h6gwMsvR64mN6oEEtvFKokbgqVBDZINwlUEjd7XkmQ3TcrwdIbjFZ0v7cIYOktDrD0HIAPLFYhF+kblGDprQqx9FahZHJbSCbYIN0mkExu9zyZkN23K8PS2xVi6bmRjG+hcXOIpXeYB3cGLNWJpXcksPROB1h6B3AxvUshlt4lVEncHSoJbJDuFqgk7vG8kiC771GCpXcareh+lwlg6TIHWHouwAcWq5CL9J1KsPRehVh6r1AyuS8kE2yQ7hNIJvd7nkzI7vuVYen9CrH0vEjGt9C4OcTSB8yDBwOW6sTSBxJY+qADLH0AuJg+pBBLHxKqJB4OlQQ2SA8LVBKPeF5JkN2PKMHSB41WdL+PCmDpow6w9DyADyxWIRfpB5Vg6WMKsfQxoWTyeEgm2CA9LpBMnvA8mZDdTyjD0icUYun5kYxvoXFziKVPmgdPBSzViaVPJrD0KQdY+iRwMX1aIZY+LVRJPBMqCWyQnhGoJJ71vJIgu59VgqVPGa3ofp8TwNLnHGDp+QAfWKxCLtJPKcHS5xVi6fNCyeSFkEywQXpBIJm86HkyIbtfVIalLyrE0gsiGd9C4+YQS18yD14OWKoTS19KYOnLDrD0JeBi+opCLH1FqJJ4NVQS2CC9KlBJvOZ5JUF2v6YES182WtH9vi6Apa87wNILAD6wWIVcpF9WgqVvKMTSN4SSyZshmWCD9KZAMnnL82RCdr+lDEvfUoilF0YyvoXGzSGWvm0evBOwVCeWvp3A0nccYOnbwMX0XYVY+q5QJfFeqCSwQXpPoJJ43/NKgux+XwmWvmO0ovv9QABLP3CApRcCfGCxCrlIvwP0Z26UuZCgr/9GuL4K2ph+PoxFfxTvH8f78nj/JN4/jffP4v3zeF8R71/E+5fx/lW8fx3v38T7t/H+Xbx/H+8r4/2HeP8x3n+K958pccf7r/H+W7z/Hu+r4v2PeP8z3v+K99Xx/rdxmL0OPzQJ3j7+KPH448Tj5YnHnyQef5p4/Fni8eeJxysSj79IPP4y8firxOOvE4+/STz+NvH4u8Tj7xOPVyYe/5B4/GPi8U+Jxz8nHv+SePxr4vFvice/Jx6vSjz+I/H4z8TjvxKPVyce/527fkGHXnf4nKnoWvEhcN05uLIMrSX9V9G19qNcTF8Ui4+B/jvEe/+Vd51eXnGbexmb058A/TfXZ/8VrdWZ/rRiNhcwm9OfAf13qK/+65WhM/35/25zQcLm9Aqg/+Z56L8+09fTmf7if7O5JIvN6S+B/jvMN/+VZNWZ/mrjbS7+B5vTXwP9d7hP/iv+R53pbzbO5l4bsDn9LdB/833xX/EGdaa/+/c2T/l/bE5/D/TfAh/8V/z/6kyv/Hc2F/wLm9M/AP13xH/tv4J/pTP94/9vc+9/aXP6J6D/jvwv/Vf0r3Wmf96gzUXTN8Lm9C9A/x31X/mveKN0pn/9Z5tLNtLm9G9A/x39H/ivdPpG60z/nt3mgv/B5vQqoP8WuvZfwf+kM/3H+jan/0eb038C/XeMS/9N/Z91pv/KtLmwAjanVwP9d6wj//WaXiGd6b9zce8l8vfsKuq/RY78V1CxLQ18ny09F+i/45T4D/g+UXoe0H+LlfgP+D5H+nCg/45X4j8gp6cXAP13ghL/ATkzfSTQfycq8R+Qk9JHA/23RIn/gHV++hig/05S4j9gnZpeBPTfyUr8B6yz0ouB/jtFif+AdUL6BKD/lirxHzDPpZcA/XeqEv8B1+n0yUD/nabEf8B1Jr0U6L/TlfgPOE/SwGsmjfRfXrTm/tk2pj96z4nea6P37ug9S3oPlN77pfeS6T10ek+ePougzzboMx36jIg+G6PP2ugzRvrMkj6rpc9+6TNv+gyd7h2gexHoHgy6p4PuZaF7Y+ieILrHiO6tonu16B41ur+ONA2K99XxPti01t7LojX33V1v2jtM+4BpnzTtS6Z927TLTfu1aX827WrTVslZ09YxbVPTtjNtN9MWmbavaQeadoRpx5t2kmlnmHa2aeeZdqFpl5j2TNNeZNqrTXuLaZeZ9lHTPmfa1037gWlXmHalaVeZNpW7pq1h2oambWXazqYtMG2pafubdohpx5h2Z9NON+0s0x5s2iNMu9i0p5r2PNNeblr7t8DtH1970LT25wXt7znYL9C0YddpefxMa+/XtPdx2vs77X2f9n5Qe5+ovX/U3ldq7ze196Ha+1Ptfav2flZ7n6u9/9XeF2vvl7X30dr7a+19t/Z+XHufrr1/197Xa+/3tfcB2/uD7X3D9n7iD02b/Foe/IsnKdx6T1KrRP+8wTSL9d2rWLDvEsG+SwX7niTY92TBvqfwbyrmmHmUa9qUaSuZNs+0ldl8O9IcU96094DbPumcvdbz2Dn7fCV2zj6fYueSXzCrFq3/Lc1qUeYX0Pj4tJWZtqCCm8S3L8nmusyOKIu9OVn8kpvFf/b5vCz+4/Gwz9u42G+rVhPwVz64T9JYPcrckl/4K2PH+cz+GgL21RSwr8ZG2FeT2VdLwL7aAvbV2gj7ajP76gjYV1fAvjobYV9dZl89AfvAfaapz/oCOhti+yymODSI/n0cGrI4NBKwrzG4T+qjCdNvbbXa89nzjZltTbA6yr/g3yjK9Kl93ERu3HL7m/4/9jfNoqOpQ/ubBvuD/cH+YH+wHzxuujy/83Fp21B+51qaQbWsye8S8W3O9FtbrfZ89jyPb3OsjvL4NosyfWofN2fjBvuh4wb7o2B/sD/YH+wP9gf7g/3B/mB/sD/YH+wP9gf7g/3B/mB/sD/Y74P9+ez5XKYF/D57ekPv7zfLoiXlkZZKHmnJ80hLZY+0VPFIS1WPtFTzSEt1j7Tke6SlhkdaanqkpZZHWmp7pKWOR1rqeqSlnkda6nukpYFHWhp6pKWRR1oae6SliUdaBO/92WgtOf+xFv59koids8/nsnOW7/j3TlqYY/69k5bmmH/vpBWz055rbY6rsHNtzHFVdq4tO7ZtO3NcnZ1rb45rsHMdzHEtdq6jOa7DznUyx/XYuc7muD4718UcN2DnuprjRuyc9Rv3s/Vbc3bO+q0FO2f91pKds35rxc5Zv7Vm56zf2rBz1m/cj9Zv7dg5e122Z+esLzuwc7ae68jOWf92YudsfdOZnbM+78LO2Xxv/Uj2X5qz7nn7Wn4tds3Sjz3mc8qOXWbagopt5XOKj1PGHtuxqjMNXTzQ0tQjLU080tLYIy2NPNLS0CMtDTzSUt8jLfU80lLXIy11PNJS2yMttTzSUtMjLTU80pLvkZbqHmmp5pGWqh5pqeKRlsoeacnzSEslj7SkPNKSm0WLxGfmlkdps8zYhOmwmjoxHR3BPqE+OmTR0ZHpsON3YDraY3X0oj7aZdHRnumw47djOtpidRRSH22y6GjLdNjx2zAdrbE6iqiPVll0tGY67Pj8/auWWB29qY8WWXS0ZDrs+C2YDvC9HX2oj2ZZdDRnOuz4zZiOTbA6Mu4xobWcHtt5asdKsdecYd5sobqSv3fJ34vqZo75+1jdzTF/D2xTc9yGnethjvl7bz3NMX/fbkPv+XVj52xO6M7O2Zy1KTtnc2oPds7mfDt+FfM68G9w9KKxLGPaLSfxuIwd8/dILbPzz87Av+dRfo00SGixj+1Y+UxDHTktxfn/MLbd+D1QDQT8ECX8YLcGWbSkPNJSySMteR5pqeyRlioeaanqkZZqHmmp7pGWfI+01PBIS02PtNTySEttj7TU8UhLXY+01PNIS32PtOT8x1r+6d4N+zz/vLwhO7at/cyR30PROGEnnbPvl/D7KuxnyjXZOcs9/F4Ly4612TnLTPx3TnOz2GZrVa7d1oz8XgtbuzVm52wN1YSds7VMU3bO1hSc2ayP+H0a1kdWO405N7W+nblZ7OT92GPp+374OGXssR2L36PQ3AMt9T3SUs8jLXU90lLHIy21PdJSyyMtNT3SUsMjLfkeaanukZZqHmmp6pGWKh5pqeyRljyPtFTySEvKIy25WbSAf+dzvd+btrVuU6bDauL3/qN/9zonoaMNG5d//wH8G97ln+k2zGI/Zyo7fkPBOHC2s33TvCjLlbNd4LPY8jjazztpm8/sas38JzFuq8S4jRLj8s+aKpvXWK32/6bYa4bmrovDdua4OuuPf8egTWIszsL2OfsZX1sB2+0Ydjzr87bM9rbM9jbs/zRhttvXbM9sH5da9//A9zKUf2ZuP7fNZbrbM63g+zjK75/g93HY/tuxc53ZsV0T7P/h93l0Zjol1iauw47Pfx+5axad/P6cLonXCXzOX379cR383iH+Ob99za7s2hrLri2JOG8Sre+/jswX3cFj8nsUuD/4VsaOuzMtPbBaCvl9EP9GSw+mpSdWS4FU7cL/MKa11WrPZ8/z7woWYHWU13M9o0yf2scFbNxgP3RcVfbze426/cda8pmGTeW0FOZHbq4D7lteOy9gtXMabBv1WQS2g2LXK1q3zWd2FTH/SYxbmBg3nRg3JxHD+Uyr/b8p9poJ9u8LxvsiVjvb/vgckFgX+kTrNjsmZ9re5rgP0yFRvxVn0cHZ0o5fzHRI1EElWXTw+5bt+CVMRylYR7WEDto2VI+UMi2bC2jZbCO0bM609BXQssVGaOnLtGwloGXLjdCyFdPST0BL2UZo6ce0bC2gpf9GaLHj0/8bYI753NoGq6887w9IaLGP7Vj5TENvQS35WcbmftjMAz9YDX3+Qz9s4YEfrIbi/9APW3rgB6uh8X/ohzIP/GDH6/Qf+qG/B36wGnId+6E6O8fv1xuIHbuYj8nfdx3IxtwWbC/1OQhsB10320WZ24by8iBm3xCslnKOGsr6L2Nj8HGHgf3Kx80xux3Dnk+x43fsRc1eR5u97qxmuhYHZ3kdP94u8X/y2fODhW0ewnSUscd2LGLPF5mtg7Po5nPePr8t0y3BhIOYDjs+/7058HVZPke47bRtaI4MYVrAcSufI8NZ/2VsDD7uCLDf+bh2jtgx7PkUO/6WXTcj1h2uvW6sZpojQ7O8jh8n51A+e36osM18rpaxx3YsmiPLma1Ds+gexHTb5zk/SMwRPrft+HyOgK/L8jnCbadtQ3NkGNMCjlv5HBnJ+i9jY/Bxtwf7nY9r54gdw55P8dfYm2XY62iz143VTHNkeJbX8ePkHMpnzw8XtpnP1TL22I5Fc+QXNkeGZ9HN8599Xvq9RT637fh8joCvy/I5wm2nbUNzZATTAo5b+RwZxfovY2PwcUeD/c7HtXPEjmHPp9hxAzZHRq87XHvdWM00R0ZmeR0/Ts6hfPb8SGGb+VwtY4/tWDRHqjFbR2bRzfOffZ6/7yAxR/jctuPzOQK+LsvnCLedtg3Nke2ZFnDcyufIGNZ/GRuDj7sD2O98XDtH7Bj2fIodd2bXzQ7rDtdeN1YzzZFRWV7Hj5NzKJ89P0rYZj5Xy9hjOxbNkRbM1lFZdPP8Z5+Xvv+Rz207Pp8j4OuyfI5w22nb0BwZzbSA41Y+R8ay/svYGHzccWC/83HtHLFj2PMpdrwZu27GrTtce91YzTRHxmR5HT9OzqF89vwYYZv5XC1jj+1YNEd6MlvHZNHN8599nr9fKTFH+Ny24/M5Ar4uy+cIt522Dc2RHZgWcNzK58h41n8ZG4OPuyPY73xcO0fsGPZ8ih0PY9fNjusO1143VjPNkbFZXsePk3Monz0/VthmPlfL2GM7Fs2R/szWsVl08/xnn7cIQ9eWjRt/j3msgC3/NN/HMn31EtoFtBTnZxmb33+avM9ZYg3hvrDvt/PvP9tzvF4oY/fOWN3dWD/8WrH3CvF7Xvk13SLxf6jP8YnXke07YW0vvw+V66BtQ2vZTkzLRKyW8rVsZ9Z/GRuDj7sLdtw0H9euZXYMez7Fjmey+b3LusO114DVTDGckOV1/HjHxP/JZ89PELZ5ItNRxh7bsegan8JsnZBFN7+f0z7P85HEXN2J6bDj87lqdfD72MDXarn/JiT8Zx/zWHZL+EtAS2F+lrH5fZfWX8n7LvOhOtLF1GdNcJ/872PYbUPrkx2/arTuu667T5szfNacabNz2P+3fVp+q876yGXHKfZ/KkXr68jLcq5ylnNVovW3quy4GjvOZ/+vekIn/zsg/LdCrGb7XJVofT9BJ6HdchN9Fxb0KSqaVtxrWrowPamgV+nkkt4FRb0n9ylJl6R7l/Se2quksHBaSVFJcenk0uKC0nRR4bT09N6lhdNN57lAnZVSuOTEbc4B+7NyCue/VJQl8AKa81LYxG+3KizhVEpcY7TxH1dE2xQlxkn6sVYkPKkkgkQORfdbFXjBStldNQWPUYFd3ddmhfhgddzmmjZlWtroHffqqTUZgn9j3J7nW9L+ivo0P4WtdCoz/fnGxmrM1hrxcU1jaz57rT2/MX6rFR/XNn3VYH3Z85J+qyPotzrGxlrM1rrxcT1ja032Wns+2Qe1q83z1NICWT+15pMs6qMWe609n+wjz/zf+tb38d4w/qeR6aM2e609zzd0wkeuJY2B8XOVSBtF+ESaw/psEhvSNN6bxXvz1JpPOVrGe6t4bx3vbeK9bby3i/f28d4h3jvGe6fUmk9/usR713jfJN67xXv3eN803nuk1rwbTBUHOatXvBfGe1G89473PvFeHO8l8V6aWvMu+ebxvkW89433LeN9K4pXvPdLrXnXbOt4HxDv28T7wHjfNt63i/dB8T443ofE+9DUmncTh8f7iHgfGe/bx/uoeB8d72PifYfUmnePxrFrl/+KXm4iprxiLwPFQqBAKchjWjkx8Oqfnq8EHbeogP9SYMSusSiL3yI2ftVoHZHEFNbvgDl7jNtzzsxpszNYLJXoISeLZfw3CFPs3NpVzbSi3EOD1InC1EpOLR4065uKLuXjUxXva9p02twt5VxzQQU3rndH5uvARBXsk4JEDkX3u1MKd/FL2b1TCh4j0TdGdgJOqFS0fg6T0NwkJeNbaNzSgn3HvfPFyX7bfCJzvq1dcqPMb/HYeNiX0mL3d7R+rHLYca55TWoDr8n5h354DWX/v62hwD4RqQdFF98c41wK4C9mIHpMgayaGBMNhROAi+nOGROyYr25qiR2FqokdgmVBDZIuwhUErt6XkmQ3bsKVRJojJhotKL73Q08QWkSUp88I9GWAseuCRCrkIv0RKGqCR33SQqxdJJQMpkckgk2SJMFkskUz5MJ2T1FGZZOUYilTQOWZmDpVOP0aQFLdWLp1ASWTnOApVOBi+l0hVg6XaiS2D1UEtgg7S5QSezheSVBdu+hBEunGa3ofvcUwNI9HWBpUyBWIRfpaUqwdIZCLJ0hlEz2CskEG6S9BJLJ3p4nE7J7b2VYurdCLG0WsDQDS/cxTp8ZsFQnlu6TwNKZDrB0H+BiOkshls4SqiT2DZUENkj7ClQS+3leSZDd+ynB0plGK7rf/QWwdH8HWNoMiFXIRXqmEiydrRBLZwslkzkhmWCDNEcgmRzgeTIhuw9QhqUHKMTS5gFLM7D0QOP0gwKW6sTSAxNYepADLD0QuJgerBBLDxaqJA4JlQQ2SIcIVBJzPa8kyO65SrD0IKMV3e+hAlh6qAMsbQ7EKuQifZASLJ2nEEvnCSWTw0IywQbpMIFkcrjnyYTsPlwZlh6uEEtbBCzNwNL5xukLApbqxNL5CSxd4ABL5wMX0yMUYukRQpXEkaGSwAbpSIFK4ijPKwmy+yglWLrAaEX3e7QAlh7tAEtbALEKuUgvUIKlCxVi6UKhZHJMSCbYIB0jkEyO9TyZkN3HKsPSYxViacuApRlYusg4/biApTqxdFECS49zgKWLgIvpYoVYuliokjg+VBLYIB0vUEmc4HklQXafoARLjzNa0f2eKIClJzrA0pZArEIu0scpwdIlCrF0iVAyOSkkE2yQThJIJid7nkzI7pOVYenJCrG0VcDSDCw9xTh9acBSnVh6SgJLlzrA0lOAi+mpCrH0VKFK4rRQSWCDdJpAJXG655UE2X26EixdarSi+z1DAEvPcIClrYBYhVyklyrB0jMVYumZQsnkrJBMsEE6SyCZnO15MiG7z1aGpWcrxNLWAUszsPQc4/RzA5bqxNJzElh6rgMsPQe4mJ6nEEvPE6okzg+VBDZI5wtUEhd4XkmQ3RcowdJzjVZ0vxcKYOmFDrC0NRCrkIv0uUqw9CKFWHqRUDK5OCQTbJAuFkgml3ieTMjuS5Rh6SUKsbRNwNIMLL3UOP2ygKU6sfTSBJZe5gBLLwUuppcrxNLLhSqJK0IlgQ3SFQKVxJWeVxJk95VKsPQyoxXd71UCWHqVAyxtA8Qq5CJ9mRIsvVohll4tlEyuCckEG6RrBJLJtZ4nE7L7WmVYeq1CLG0bsDQDS68zTr8+YKlOLL0ugaXXO8DS64CL6Q0KsfQGoUrixlBJYIN0o0AlcZPnlQTZfZMSLL3eaEX3e7MAlt7sAEvbArEKuUhfrwRLb1GIpbcIJZNbQzLBBulWgWRym+fJhOy+TRmW3qYQS9sFLM3A0tuN0+8IWKoTS29PYOkdDrD0duBieqdCLL1TqJK4K1QS2CDdJVBJ3O15JUF2360ES+8wWtH93iOApfc4wNJ2QKxCLtJ3KMHSZQqxdJlQMrk3JBNskO4VSCb3eZ5MyO77lGHpfQqxtH3A0gwsvd84/YGApTqx9P4Elj7gAEvvBy6mDyrE0geFKomHQiWBDdJDApXEw55XEmT3w0qw9AGjFd3vIwJY+ogDLG0PxCrkIv2AEix9VCGWPiqUTB4LyQQbpMcEksnjnicTsvtxZVj6uEIs7RCwNANLnzBOfzJgqU4sfSKBpU86wNIngIvpUwqx9CmhSuLpUElgg/S0QCXxjOeVBNn9jBIsfdJoRff7rACWPusASzsAsQq5SD+pBEufU4ilzwklk+dDMsEG6XmBZPKC58mE7H5BGZa+oBBLOwYszcDSF43TXwpYqhNLX0xg6UsOsPRF4GL6skIsfVmoknglVBLYIL0iUEm86nklQXa/qgRLXzJa0f2+JoClrznA0o5ArEIu0i8pwdLXFWLp60LJ5I2QTLBBekMgmbzpeTIhu99UhqVvKsTSTgFLM7D0LeP0twOW6sTStxJY+rYDLH0LuJi+oxBL3xGqJN4NlQQ2SO8KVBLveV5JkN3vKcHSt41WdL/vC2Dp+w6wtBMQq5CL9NtKsPQDhVj6gVAy+TAkE2yQPhRIJh95nkzI7o+UYelHCrG0c8DSDCz92Dh9ecBSnVj6cQJLlzvA0o+Bi+knCrH0E6FK4tNQSWCD9KlAJfGZ55UE2f2ZEixdbrSi+/1cAEs/d4ClnYFYhVyklyvB0hUKsXSFUDL5IiQTbJC+EEgmX3qeTMjuL5Vh6ZcKsbRLwNIMLP3KOP3rgKU6sfSrBJZ+7QBLvwIupt8oxNJvhCqJb0MlgQ3StwKVxHeeVxJk93dKsPRroxXd7/cCWPq9AyztAsQq5CL9tRIsXakQS1cKJZMfQjLBBukHgWTyo+fJhOz+URmW/qgQS7sGLM3A0p+M038OWKoTS39KYOnPDrD0J+Bi+otCLP1FqJL4NVQS2CD9KlBJ/OZ5JUF2/6YES382WtH9/i6Apb87wNKuQKxCLtI/K8HSVQqxdJVQMvkjJBNskP4QSCZ/ep5MyO4/lWHpnwqxdJOApRlY+pdx+uqApTqx9K8Elq52gKV/ARfTvxVi6d9ClcTa8iEKlQQkSORFdL85lfyuJMjunErwGIlg6WqjFd1vbiU8llKf0li6CRCrkIv0aiVYmqqE85+rZJKqJJNMKoVkgg1SJYFkkud5MiG784SSid0kfVpQwc0VlnYLWJqBpZXNNVeFXXsBSzF9OsFSCiDHUgqkNJZWBi6mVSvpw9KqQpVEtVBJYINUTaCSqO55JUF2V1eCpVWMVnS/+QJYmu8AS7sBsRS5SFephL2O7IaOew2FWFpDKJnUDMkEG6SaAsmklufJhOyupQxLaynE0u4BSzOwtLa55uoELNWJpbUTWFrHAZbWBi6mdRViaV2hSqJeqCSwQaonUEnU97ySILvrK8HSOkYrut8GAljawAGWdgdiKXKRrqMESxsqxNKGQsmkUUgm2CA1EkgmjT1PJmR3Y2VY2lghlm4asDQDS5uYa65pwFKdWNokgaVNHWBpE+Bi2kwhljYTqiSah0oCG6TmApVEC88rCbK7hRIsbWq0ovttKYClLR1g6aZALEUu0k2VYGkrhVjaSiiZtA7JBBuk1gLJpI3nyYTsbqMMS9soxNIeAUszsLStuebaBSzViaVtE1jazgGWtgUupu0VYml7oUqiQ6gksEHqIFBJdPS8kiC7OyrB0nZGK7rfTgJY2skBlvYAYilykW6nBEs7K8TSzkLJpEtIJtggdRFIJl09TyZkd1dlWNpVIZb2DFiagaWbmGuuW8BSnVi6SQJLuznA0k2Ai2l3hVjaXaiS2DRUEtggbSpQSfTwvJIgu3sowdJuRiu6354CWNrTAZb2BGIpcpHupgRLCxRiaYFQMkmHZIINUlogmfTyPJmQ3b2UYWkvhVhaELA0A0sLzTVXFLBUJ5YWJrC0yAGWFgIX094KsbS3UCXRJ1QS2CD1Eagkij2vJMjuYiVYWmS0ovstEcDSEgdYWgDEUuQiXaQES0sVYmmpUDLZLCQTbJA2E0gmm3ueTMjuzZVh6eYKsTQdsDQDS7cw11zfgKU6sXSLBJb2dYClWwAX0y0VYumWQpXEVqGSwAZpK4FKoszzSqL84lSCpX2NVnS//QSwtJ8DLE0DsRS5SPdVgqX9FWJpf6FksnVIJtggbS2QTAZ4nkzI7gHKsHSAQiztFbA0A0u3MdfcwIClOrF0mwSWDnSApdsAF9NtFWLptkKVxHahksAGaTuBSmKQ55UE2T1ICZYONFrR/Q4WwNLBDrC0FxBLkYv0QCVYOkQhlg4RSiZDQzLBBmmoQDIZ5nkyIbuHKcPSYQqxtDBgaQaWDjfX3IiApTqxdHgCS0c4wNLhwMV0pEIsHSlUSWwfKglskLYXqCRGeV5JkN2jlGDpCKMV3e9oASwd7QBLC4FYilykRyjB0jEKsXSMUDLZISQTbJB2EEgmYz1PJmT3WGVYOlYhlhYFLM3A0nHmmhsfsFQnlo5LYOl4B1g6DriY7qgQS3cUqiR2CpUENkg7CVQSEzyvJMjuCUqwdLzRiu53ogCWTnSApUVALEUu0uOVYOnOCrF0Z6FksktIJtgg7SKQTHb1PJmQ3bsqw9JdFWJp74ClGVi6m7nmJgUs1YmluyWwdJIDLN0NuJhOVoilk4UqiSmhksAGaYpAJTHV80qC7J6qBEsnGa3ofqcJYOk0B1jaG4ilyEV6khIsna4QS6cLJZPdQzLBBml3gWSyh+fJhOzeQxmW7qEQS/sELM3A0j3NNTcjYKlOLN0zgaUzHGDpnsDFdC+FWLqXUCWxd6gksEHaW6CS2MfzSoLs3kcJls4wWtH9zhTA0pkOsLQPEEuRi/QMJVg6SyGWzhJKJvuGZIIN0r4CyWQ/z5MJ2b2fMizdTyGWFgcszcDS/c01NztgqU4s3T+BpbMdYOn+wMV0jkIsnSNUSRwQKglskA4QqCQO9LySILsPVIKls41WdL8HCWDpQQ6wtBiIpchFerYSLD1YIZYeLJRMDgnJBBukQwSSyVzPkwnZPVcZls5ViKUlAUszsPRQc83NC1iqE0sPTWDpPAdYeihwMT1MIZYeJlRJHB4qCWyQDheoJOZ7XkmQ3fOVYOk8oxXd7wIBLF3gAEtLgFiKXKTnKcHSIxRi6RFCyeTIkEywQTpSIJkc5XkyIbuPUoalRynE0tKApRlYerS55hYGLNWJpUcnsHShAyw9GriYHqMQS48RqiSODZUENkjHClQSizyvJMjuRUqwdKHRiu73OAEsPc4BlpYCsRS5SC9UgqWLFWLpYqFkcnxIJtggHS+QTE7wPJmQ3Scow9ITFGLpZgFLM7D0RHPNLQlYqhNLT0xg6RIHWHoicDE9SSGWniRUSZwcKglskE4WqCRO8bySILtPUYKlS4xWdL9LBbB0qQMs3QyIpchFeokSLD1VIZaeKpRMTgvJBBuk0wSSyemeJxOy+3RlWHq6QizdPGBpBpaeYa65MwOW6sTSMxJYeqYDLD0DuJiepRBLzxKqJM4OlQQ2SGcLVBLneF5JkN3nKMHSM41WdL/nCmDpuQ6wdHMgliIX6TOVYOl5CrH0PKFkcn5IJtggnS+QTC7wPJmQ3Rcow9ILFGLpFgFLM7D0QnPNXRSwVCeWXpjA0oscYOmFwMX0YoVYerFQJXFJqCSwQbpEoJK41PNKguy+VAmWXmS0ovu9TABLL3OApVsAsRS5SF+kBEsvV4illwslkytCMsEG6QqBZHKl58mE7L5SGZZeqRBL+wYszcDSq8w1d3XAUp1YelUCS692gKVXARfTaxRi6TVClcS1oZLABulagUriOs8rCbL7OiVYerXRiu73egEsvd4BlvYFYilykb5aCZbeoBBLbxBKJjeGZIIN0o0CyeQmz5MJ2X2TMiy9SSGWbhmwNANLbzbX3C0BS3Vi6c0JLL3FAZbeDFxMb1WIpbcKVRK3hUoCG6TbBCqJ2z2vJMju25Vg6S1GK7rfOwSw9A4HWLolEEuRi/QtSrD0ToVYeqdQMrkrJBNskO4SSCZ3e55MyO67lWHp3QqxdKuApRlYeo+55pYFLNWJpfcksHSZAyy9B7iY3qsQS+8VqiTuC5UENkj3CVQS93teSZDd9yvB0mVGK7rfBwSw9AEHWLoVEEuRi/QyJVj6oEIsfVAomTwUkgk2SA8JJJOHPU8mZPfDyrD0YYVYWhawNANLHzHX3KMBS3Vi6SMJLH3UAZY+AlxMH1OIpY8JVRKPh0oCG6THBSqJJzyvJMjuJ5Rg6aNGK7rfJwWw9EkHWFoGxFLkIv2oEix9SiGWPiWUTJ4OyQQbpKcFkskznicTsvsZZVj6jEIs7RewNANLnzXX3HMBS3Vi6bMJLH3OAZY+C1xMn1eIpc8LVRIvhEoCG6QXBCqJFz2vJMjuF5Vg6XNGK7rflwSw9CUHWNoPiKXIRfo5JVj6skIsfVkombwSkgk2SK8IJJNXPU8mZPeryrD0VYVY2j9gaQaWvmauudcDlurE0tcSWPq6Ayx9DbiYvqEQS98QqiTeDJUENkhvClQSb3leSZDdbynB0teNVnS/bwtg6dsOsLQ/EEuRi/TrSrD0HYVY+o5QMnk3JBNskN4VSCbveZ5MyO73lGHpewqxdOuApRlY+r655j4IWKoTS99PYOkHDrD0feBi+qFCLP1QqJL4KFQS2CB9JFBJfOx5JUF2f6wESz8wWtH9LhfA0uUOsHRrIJYiF+kPlGDpJwqx9BOhZPJpSCbYIH0qkEw+8zyZkN2fKcPSzxRi6YCApRlY+rm55lYELNWJpZ8nsHSFAyz9HLiYfqEQS78QqiS+DJUENkhfClQSX3leSZDdXynB0hVGK7rfrwWw9GsHWDoAiKXIRXqFEiz9RiGWfiOUTL4NyQQbpG8Fksl3nicTsvs7ZVj6nUIs3SZgaQaWfm+uuZUBS3Vi6fcJLF3pAEu/By6mPyjE0h+EKokfQyWBDdKPApXET55XEmT3T0qwdKXRiu73ZwEs/dkBlm4DxFLkIr1SCZb+ohBLfxFKJr+GZIIN0q8CyeQ3z5MJ2f2bMiz9TSGWDgxYmoGlv5trblXAUp1Y+nsCS1c5wNLfgYvpHwqx9A+hSuLPUElgg/SnQCXxl+eVBNn9lxIsXWW0ovtdLYClqx1g6UAgliIX6VVKsPRvhVj6t1AyifLWHYZkUsE+KUjkUHS/OXl+JxOyOycPHiNRLOU+Lajg5gpLtw1YmoGlueaaS7FrL2Appk8nWEoB5FhKgZTG0lzgYlopTx+WVsqTqSTyQiWBDVKeQCVR2fNKguyuLFRJoDEiZbSi+60CnqA0CalPaSzdFoilyEU6lYe9juyGjnvVPJz/XCWTqkLJpFpIJtggVRNIJtU9TyZkd3VlWFpdIZZuF7A0A0vzzTVXI2CpTizNT2BpDQdYmg9cTGsqxNKaQpVErVBJYINUS6CSqO15JUF211aCpTWMVnS/dQSwtI4DLN0OiKXIRbqGEiytqxBL6wolk3ohmWCDVE8gmdT3PJmQ3fWVYWl9hVg6KGBpBpY2MNdcw4ClOrG0QQJLGzrA0gbAxbSRQixtJFRJNA6VBDZIjQUqiSaeVxJkdxMlWNrQaEX321QAS5s6wNJBQCxFLtINlWBpM4VY2kwomTQPyQQbpOYCyaSF58mE7G6hDEtbKMTSwQFLM7C0pbnmWgUs1YmlLRNY2soBlrYELqatFWJpa6FKok2oJLBBaiNQSbT1vJIgu9sqwdJWRiu633YCWNrOAZYOBmIpcpFupQRL2yvE0vZCyaRDSCbYIHUQSCYdPU8mZHdHZVjaUSGWDglYmoGlncw11zlgqU4s7ZTA0s4OsLQTcDHtohBLuwhVEl1DJYENUleBSmITzysJsnsTJVja2WhF99tNAEu7OcDSIUAsRS7SnZVgaXeFWNpdKJlsGpIJNkibCiSTHp4nE7K7hzIs7aEQS4cGLM3A0p7mmisIWKoTS3smsLTAAZb2BC6maYVYmhaqJHqFSgIbpF4ClUSh55UE2V2oBEsLjFZ0v0UCWFrkAEuHArEUuUgXKMHS3gqxtLdQMukTkgk2SH0Ekkmx58mE7C5WhqXFCrF0WMDSDCwtMddcacBSnVhaksDSUgdYWgJcTDdTiKWbCVUSm4dKAhukzQUqiS08ryTI7i2UYGmp0Yrut68AlvZ1gKXDgFiKXKRLlWDplgqxdEuhZLJVSCbYIG0lkEzKPE8m5RenMiwtU4ilwwOWZmBpP3PN9Q9YqhNL+yWwtL8DLO0HXEy3VoilWwtVEgNCJYEN0gCBSmIbzysJsnsbJVja32hF9ztQAEsHOsDS4UAsRS7S/ZVg6bYKsXRboWSyXUgm2CBtJ5BMBnmeTMjuQcqwdJBCLB0RsDQDSweba25IwFKdWDo4gaVDHGDpYOBiOlQhlg4VqiSGhUoCG6RhApXEcM8rCbJ7uBIsHWK0ovsdIYClIxxg6QggliIX6SFKsHSkQiwdKZRMtg/JBBuk7QWSySjPkwnZPUoZlo5SiKUjA5ZmYOloc82NCViqE0tHJ7B0jAMsHQ1cTHdQiKU7CFUSY0MlgQ3SWIFKYpznlQTZPU4Jlo4xWtH9jhfA0vEOsHQkEEuRi/QYJVi6o0Is3VEomewUkgk2SDsJJJMJnicTsnuCMiydoBBLtw9YmoGlE801t3PAUp1YOjGBpTs7wNKJwMV0F4VYuotQJbFrqCSwQdpVoJLYzfNKguzeTQmW7my0ovudJIClkxxg6fZALEUu0jsrwdLJCrF0slAymRKSCTZIUwSSyVTPkwnZPVUZlk5ViKWjApZmYOk0c81ND1iqE0unJbB0ugMsnQZcTHdXiKW7C1USe4RKAhukPQQqiT09ryTI7j2VYOl0oxXd7wwBLJ3hAEtHAbEUuUhPV4KleynE0r2EksneIZlgg7S3QDLZx/NkQnbvowxL91GIpaMDlmZg6Uxzzc0KWKoTS2cmsHSWAyydCVxM91WIpfsKVRL7hUoCG6T9BCqJ/T2vJMju/ZVg6SyjFd3vbAEsne0AS0cDsRS5SM9SgqVzFGLpHKFkckBIJtggHSCQTA70PJmQ3Qcqw9IDFWLpmIClGVh6kLnmDg5YqhNLD0pg6cEOsPQg4GJ6iEIsPUSokpgbKglskOYKVBKHel5JkN2HKsHSg41WdL/zBLB0ngMsHQPEUuQifbASLD1MIZYeJpRMDg/JBBukwwWSyXzPkwnZPV8Zls5XiKU7BCzNwNIF5po7ImCpTixdkMDSIxxg6QLgYnqkQiw9UqiSOCpUEtggHSVQSRzteSVBdh+tBEuPMFrR/S4UwNKFDrB0ByCWIhfpI5Rg6TEKsfQYoWRybEgm2CAdK5BMFnmeTMjuRcqwdJFCLB0bsDQDS48z19zigKU6sfS4BJYudoClxwEX0+MVYunxQpXECaGSwAbpBIFK4kTPKwmy+0QlWLrYaEX3u0QAS5c4wNKxQCxFLtKLlWDpSQqx9CShZHJySCbYIJ0skExO8TyZkN2nKMPSUxRi6biApRlYutRcc6cGLNWJpUsTWHqqAyxdClxMT1OIpacJVRKnh0oCG6TTBSqJMzyvJMjuM5Rg6alGK7rfMwWw9EwHWDoOiKXIRfpUsD/p8syJbV1NvjWt7X9iak0Cm2bamaY9yLQLTHucaZea9lzTXmba6017h2kfMO2Tpn3JtG+bdrlpvzbtz6Zdbdoqlda0dUzb1LTtTNvNtEWm7WvagaYdYdrxpp1k2hmmnW3aeaZdaNolpj3TtBeZ9mrT3mLaZaZ91LTPmfZ1035g2hWmXWnaVaZNmcKhhmkbmraVaTubtsC0pabtb1r7B9PtX6izfxLA/gaj/dEL+y0je1uXfR/dFi5tzHXwd67xv2n/Mu2fpv3DtKtM+7tpfzPtr6b9xbQ/m/Yn0/5o2h9Mu9K035v2O9N+a9pvTPu1ab8y7Zem/cK0K0z7uWk/M+2npv3EtMtN+7FpPzLth6Y9i63htKHzxFngPPZPOiva99mAtWdaSZ9Jk4umT5fUeY6St+7OVaLzvDzZ2qWgYlt6ZNzHGAG7b6vst907x33sKmD37ZVlrssUWOf5uOsyDYx1+nbPr5uqcSBqpPDXzV2e290wtrmxgN13K5kvFwDnCzDWaSn/oeN8oZJ8fZESnRcr0XmJEp2XKtF5mRKdlyvReYUSnVcq0XmVEp1XK9F5jRKd1yrReZ0Sndcr0XmDEp03KtF5kxKdNyvReYsSnbcq0XmbEp23K9F5hxKddyrReZcSnXcr0XmPEp3LlOi8V4nO+5TovF+JzgeU6HxQic6HlOh8WInOR5TofFSJzseU6Hxcic4nlOh8UonOp5TofFqJzmeU6HxWic7nlOh8XonOF5TofFGJzpeU6HxZic5XlOh8VYnO15TofF2JzjeU6HxTic63lOh8W4nOd5TofFeJzveU6Hxfic4PlOj8UInOj5To/FiJzuVKdH6iROenSnR+pkTn50p0rlCi8wslOr9UovMrJTq/VqLzGyU6v1Wi8zslOr9XonOlEp0/KNH5oxKdPynR+bMSnb8o0fmrEp2/KdH5uxKdq5To/EOJzj+FdOYmdBZUbCv/YUaUzX8psTkXaPNqJTangDb/rcTmSkCbo8o6bM4D2pyjxObKQJtzldi8LdDmlBKbzwb+BlwlJTafA7Q5T4nN5wJtrqzE5vOANldRYvP5QJurKrH5AqDN1ZTYfCHQ5upKbL4IaHO+EpsvBtpcQ4nNlwBtrqnE5kuBNtdSYvNlQJtrK7H5cqDNdZTYfAXQ5rpKbL4SaHM9JTZfBbS5vhKbrwba3ECJzdcAbW6oxOZrgTY3UmLzdUCbGyux+XqgzU2U2HwD0OamSmy+EWhzMyU23wS0ubkSm28G2txCic23AG1uqcTmW4E2t1Ji821Am1srsfl2oM1tlNh8B9DmtkpsvhNoczslNt8FtLm9EpvvBtrcQYnN9wBt7qjE5mVAmzspsfleoM2dldh8H9DmLkpsvh9oc1clNj8AtHkTJTY/CLS5mxKbHwLa3F2JzQ8Dbd5Uic2PAG3uocTmR4E291Ri82NAmwuU2Pw40Oa0EpufANrcS4nNTwJtLlRi81NAm4uU2Pw00ObeSmx+BmhzHyU2Pwu0uViJzc8BbS5RYvPzQJtLldj8AtDmzZTY/CLQ5s2V2PwS0OYtlNj8MtDmvkpsfgVo85ZKbH4VaPNWSmx+DWhzmRKbXwfa3E+JzW8Abe6vxOY3gTZvrcTmt4A2D1Bi89tAm7dRYvM7QJsHKrH5XaDN2yqx+T2gzdspsfl9oM2DlNj8AdDmwUps/hBo8xAlNn8EtHmoEps/Bto8TInNy4E2D1di8ydAm0cosflToM0jldj8GdDm7ZXY/DnQ5lFKbF4BtHm0Epu/ANo8RonNXwJt3kGJzV8BbR6rxOavgTaPU2LzN0Cbxyux+VugzTsqsfk7oM07KbH5e6DNE5TYvBJo80QlNv8AtHlnJTb/CLR5FyU2/wS0eVclNv8MtHk3JTb/ArR5khKbfwXaPFmJzb8BbZ6ixObfgTZPVWLzKqDN05TY/AfQ5ulKbP4TaPPuSmyuEuFs3kOJzVWBNu+pxOZqQJtnKLG5OtDmvZTYnA+0eW8lNtcA2ryPEptrAm2eqcTmWkCbZymxuTbQ5n2V2FwHaPN+SmyuC7R5fyU21wPaPFuJzfWBNs9RYnMDoM0HKLG5IdDmA4E2NzL95Bib6W9C0t9IpL8ZSH9Dj3iQ+Ih4gepnqiepvqJ6g/Iv5SNan2m9ovlL1zPFl+xtxPw517T090Dp72P+bQagvydIf1+P/t4c/f01+ntk9Pe56O9V0d9vor9nRH/fh/7eDf39F/p7KPT3QejvZdDfj6C/p0B/X4B+b59+f55+j51+n5x+r5t+v5p+z5l+35h+75d+/5Z+D5Z+H5V+L5R+P5N+T5J+X5F+b5B+f49+j45+n41+r4x+v4t+z4p+34l+74h+/4d+D4d+H4Z+L4V+P4R+T4N+X4J+b4F+f4C+j0/fT6fva9P3l+n7vPT9Vvq+J33/kb4PSN+PK/++WLzT94no+zX0fRP6/gV9H4Huz6f71en+bbqfme7vpftd6f5Puh+S7g+k++Xo/jG6n4ruL6L7bej+E7ofg+5PoM/r6fNr+jyXPt+kz/vo8y/6PIg+H6HPC+j9c3o/md5fpfcb6f03ej+K3p+h9yuI34lnie+Id6j+p3qY6kOql6h+oHxK+YXWW1p/aD7S9Wm3/wO7Cc8eBrIJAA==", + "bytecode": "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", "verificationKey": "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" }, { @@ -214,6 +214,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -260,6 +266,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -285,6 +297,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -296,7 +314,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -306,7 +345,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -316,7 +370,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -326,7 +401,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -406,7 +496,7 @@ ] } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -475,6 +565,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -521,6 +617,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -546,6 +648,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -557,7 +665,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -567,7 +696,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -577,7 +721,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -587,7 +752,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -667,7 +847,7 @@ ] } ], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/+2dB5xeRdXG96aQTG4KJSGNJJuEFFrYnSy9LS+9915DCKEEIkkg9N57B+miYlfEjoqoiAioiIqoiIioiL3Xz+87c3cOPHuY7y4rc3777i9nfr/HnZm79z7/M8+8777lEv+npaWlaOlqA0ljWt7Y+Hhn/Nn21lp7ke9abZqcA/oJ58B+wjmon3AO7iecK/UTziH9hHNoP+F0/YRzWD/hLPsJ5/B+wjmin3CO7Ceco/oJ58r9hHOVfsK5aj/hXK2fcI7uJ5xjMnKOB87V48+x8ee4+JN/Z0L8OTH+XCP+nBRrHBTHk0lTSK2kqfFYZzw2jTSdtCZpBmkmaRZpNmkt0tqkdUjrktYjzSGtH+oktZM8aS6pg7QBaUPSRqSNSZuQNiVtRtqctAVpS9JW0X9rUoO0DWlb0nak7Uk7kHYk7UTambQLaVfSbqTdSXuQ9iTtRdqbtA9pX9J+pP1JB5AOJB1EOph0COlQ0mGkw0lHkI4kzYtrwZvjKNJ80tGkBaRjSAtJx5KOIx1POoG0iHQi6STSYtLbSCeTlpCWkpaRTiGdSlpOOo10OukM0pmks0hnk84hnUs6j3Q+6QLShaSLSBeTLiFdSrqMdDnpCtKVpKtIV5OuIV1Luo50faxleKzlBtKNpJtIN5NuId1Kuo30dtLtpDtId5Luiue2xnPvJt1Dupf0DtJ9pHeS3kV6N+l+0ntI7yW9j/R+0gdIHyR9iPRh0kdID5A+SnqQ9DHSx0mfIH2S9CnSp0mfIT1E+izpc6TPi0weJn2B9Ajpi6Qvkb5MepT0FdJjpK+SHid9jfQE6UnSU6Svk75B+ibpadK3SM+Qvk36Dum7pGdJ3yM9R/o+6QekH5KeJ/2I9ALpx6QXST8hvUT6Kell0s9IPyf9gvQK6ZekV0m/Iv2a9JuW7o/D35J+R/o96Q/x2IB47I+kP8X+n+PPv8Sff40//xZ//j3+/Ef8+c/481/x579bXm9fH931M7wH4eeTOFXN8edHq8EcH18V5vj4KjDHx1eGOT4+Cub4+EiY4+MjYI6PD4c5Pl7CHB8fBnN4nH/y8aEwx8eHwBwfXwnm+PhgmOPjg2COjw+EOT4+AOb4eAFzfLxF+IfWGX+2vcW2Ukv2v3dtoWYPdbQk6sXPKGW9gxLrMjixfpgHH8fc+Djmi8f5Jx/H/cLHcd/wcdx/fBz3KR/H/czHcd/zcXx88HF8HPFxfLzxcXxc8nF8/PLxMTDHx1eHOT4+Fub4+DiY4+PjYY6P8+uNUFdYe37d0Rl/tr215h14cCvEuBP67B9YJimwrNELlkmwXpNjf3Xgm6LA1xqvNQF8pub1acfXBXxdHrNXCQxTFFnKhLeCT7e15VaXPbJMy8tSvQyaDl6t8ec0WHs+PgY4pmde+wI8+bo8Rr43yzq5j1kdzK3RxywlMLTCHP/eVD0+7wRfaHV7fTqwzMjK0t4WWNbsBcsMYJmZlaXrddOszNcM15gN/Fwrs5dwfBbUNjsvR7UnZ7Z0X1MeI5+xGquxGquxGquxGquxrtisDuam9TELvj9aU42lva1MeGu838DP3vja4XPQ+8CzNXNtYZ2niuszA3sNhN95aLXXue6Pc8Pg+DQ1Vj8/XHNy1mt2vfflz6u41b3fxM8s8n7e2N4WPlMeAms5SeTAnAOAIfPnr9X7U/z8lT3ZJ2TNn1Pw7+Hnw3ws7I8H9Tj/68+JXYI/f5Zdz19rCBb8bj40/Mx0gCJLmfBu1s/L8XO4zJ+XV5lMFiw8Zi9cq4GKLGXCW+s7Aqw5tLpM2B8//8bnvL76boEZBimyNPt3C/g5bSvw9dXn1cwwWJGlTHg302fg+Hk1vvbJ+7l4VyZrChYes1cpGLRYyoS3go//b78LwPco+L4g82f5te9R2AvXaogiS5nwVvDxTtQcWl0m7B/O4/dOM4FvrczrULR0fy/dCWP2wrUaqshSJrwVfLwTNYdWlwn7h/PWjn18X7tO5nUowIevy2P2wrVyiixlwlvBxztRc2h1mawDta8b+2sD33qZ16EAH74uj9kL12qYIkuZ8Fbw8U7UHFpdJuwfzpsT++sC3/qZ16EAH74uj9kL16pUZCkT3go+3omaQ6vLhP3DeXx/8Bzga8+8DngfMl+Xx+2QAzMMV2QpE94KPt6JmkOry4T9w3l8T2gb8M3NvA4F+PB1ecxeuFYjFFnKhLeCj3ei5tDqMmH/cF5H7Hvg2yDzOhTgw9flMXvhWo1UZCkT3go+3omaQ6vLhP3DeRvGfgfwbZR5HQrw4evymL1wrUYpspQJbwUf70TNodVlwv7hvI1jf0Pg2yTzOhTgw9flMXvhWq2syFImvBV8vBM1h1aXCfuH8zaN/Y2Bb7PM61CAD1+Xx+yFa7WKIkuZ8Fbw8U7UHFpdJuwfzts89jcFvi0yr0MBPnxdHrMXrtWqiixlwlvBxztRc2h1mbB/OG/L2N8c+LbKvA4F+PB1ecxeuFarKbKUCW8FH+9EzaHVZcL++O99bAl8W2deh0L4d8KYvXCtRiuylAlvBR+Pa8utLhNkaeRlqe7Z2EZcM/hsm3ltC/Dh6/KYvXD9G4osZcJbwcc7UXNodTmzfzhvu9jfBvi2z7wOBfjwdXnMXrhW4xRZyoS3go93oubQ6jJBlh3zsnQElh16wbIjsOyUl6X6qGFn8GIu9inhOD42d87LUe3JnUT9PEY+Y12xWR3MbdfHLPjctYMeS0eZ8Fbw8U7UHFrd8xJmskvs7wR8u+blqzLZRbDwmL1wrRqKLGXCW8HHO1FzaHWZIMvuWVk6qteMu/WCZXdg2SMrS9ffrT3Bi7nYp4TjuA/2zMtR7ck9RP08Rj5jNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjXbFZHczt0scseC/0bmosHdW/Zyy9FWr2TtQcWt19zpjJXrG/B/DtnZevymQvwcJj9sK1aiiylAlvBR/vRM2h1WWCLPtmZZlb3Qe/Ty9Y9gWW/bKydN0Hvz94MRf7lHAc98H+eTmqPbmfqJ/HyGesxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqs+VkdzO3Vxyx4L8k+aixzq/uIpLdCzd6JmkOru08EMzkg9vcDvgPz8lWZHCBYeMxeuFYNRZYy4a3g452oObS6TJDl4Lws8wPLQb1gORhYDsnLUt1HdCh4MRf7lHAc98GheTmqPXmIqJ/HyGesxmqsxmqsxmqs+VkdzB3Qxyz42vAgPZb5ZcJbwcc7UXNoda/7MJPDYv8Q4Ds8L1+VyWGChcfshWvVUGQpE94KPt6JmkOrywRZjszK4qv/vuCIXrAcCSzzsrJ0vS84CryYi31KOI774Ki8HNWenCfq5zHyGauxGquxGquxGquxGquxGquxGquxGquxGquxGqux9hdWB3OH9TELfhZ/hBqLr+7Pkt4KNXsnag6tEONO6GMm82N/HvAdnZevymS+YOExe+FaNRRZyoS3go93oubQ6jJBlmOysnT9O08LesFyDLAszMrS9T3MseDFXOxTwnHcB8fm5aj25EJRP4+Rz1iN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1VjzszqYm9/HLHgvyQI1lq5/50l6K9Tsnag5tLr7RDCT42J/IfAdn5evyuQ4wcJj9sK1aiiylAlvBR/vRM2h1WWCLIvysnQElhN6wbIIWE7My1LdR3QSeDEX+5RwHPfBSXk5qj15oqifx8hnrCs2q4O54/qYBZ+7TtBj6SgT3go+3omaQ6t7XsJMFsf+icD3trx8VSaLBQuP2QvXqqHIUia8FXy8EzWHVpcJsixRYDm5FyxLgGVpXpbq79Yy8GIu9inhOO6DZXk5qj25VNTPY+TrL6wO5hb3MQs+xk7WY/FlwlvDx4maQ6t7/GAmp8T+UuA7NS9flckpgoXH7IVr1VBkKRPeCj7eiZpDq8uE/cN5y2P/FOA7LfM6FODD1+Uxe+FaNRRZyoS3go93oubQ6jJh/3De6bG/HPjOyLwOBfjwdXnMXrhWTpGlTHgr+Hgnag6tLpMzoPYzY/904Dsr8zoU4MPX5TF74VoNU2QpE94KPt6JmkOry4T9w3lnx/6ZwHdO5nUowIevy2P2wrUqFVnKhLeCj3ei5tDqMmH/cN65sX828J2XeR0K8OHr8vg8yIEZhiuylAlvBR+Pa8utLpPz4s9w3vmxfy7wXZB5HQrw4evymL1wrUYospQJbwUf70TNodVlwv7hvAtj/3zguyjzOhTgw9flMXvhWo1UZCkT3go+3omaQ6vLhP3DeRfH/oXAd0nmdSjAh6/LY/bCtRqlyFImvBV8vBM1h1aXCfuH8y6N/YuB77LM61CAD1+Xx+yFa9VQZCkT3go+3omaQ6vLhP3DeZfH/qXAd0XmdSjAh6/LY/bCtWoospQJbwUf70TNodVlwv7hvCtj/3LguyrzOhTgw9flMXvhWjUUWcqEt4KPd6Lm0OoyYf9w3tWxfyXwXZN5HQrw4evymL1wrRqKLGXCW8HHO1FzaHWZIMu1eVmqf0/junitq8Hn+sxrW4APX5fH7IXrf60iS5nwVvDxTtQcWl3O7B/OuyH2rwO+GzOvQwE+fF0esxeu1bWKLGXCW8HHO1FzaHWZsH8476bYvwH4bs68DgX48HV5zF64VtcqspQJbwUf70TNodVlwv7hvFti/ybguzXzOhTgw9flMXvhWjUUWcqEt4KPd6Lm0OoyYf9w3m2xfwvwvT3zOhTgw9flMXvhWjUUWcqEt4KPd6Lm0OoyYf9w3u2xfxvw3ZF5HQrw4evymL1wrRqKLGXCW8HHO1FzaHWZsH84787Yvx347sq8DgX48HV5zF64Vg1FljLhreDjnag5tLpM2D+cd3fs3wl892RehwJ8+Lo8Zi9cq4YiS5nwVvDxTtQcWl0m7B/Ouzf27wa+d2RehwJ8+Lo8Zi9cq4YiS5nwVvDxuLbc6jJh/3DefbF/L/C9M/M6FODD1+Uxe+FaNRRZyoS3go93oubQ6jJh/3Deu2L/PuB7d+Z1KMCHr8tj9sK1aiiylAlvBR/vRM2h1WXC/uG8+2P/XcD3nszrUIAPX5fH7IVr1VBkKRPeCj7eiZpDq8uE/cN57439+4HvfZnXoQAfvi6P2QvXqqHIUia8FXy8EzWHVpcJ+4fz3h/77wW+D2RehwJ8+Lo8Zi9cq4YiS5nwVvDxTtQcWl0m7B/O+2Dsvx/4PpR5HQrw4evymL1wrRqKLGXCW8HHO1FzaHWZsH8478Ox/0Hg+0jmdSjAh6/LY/bCtWoospQJbwUf70TNodVlwv7hvAdi/8PA99HM61CAD1+Xx+yFa9VQZCkT3go+3omaQ6vLhP3DeQ/G/gPA97HM61CAD1+Xx+yFa9VQZCkT3go+3omaQ6vLhP3DeR+P/QeB7xOZ16EAH74uj9kL16qhyFImvBV8vBM1h1aXCfuH8z4Z+x8Hvk9lXocCfPi6PGYvXKuGIkuZ8Fbw8U7UHFpdJuwfzvt07H8S+D6TeR0K8OHr8pi9cK0aiixlwlvBxztRc2h1mbB/OO+h2P808H028zoU4MPX5TF74Vo1FFnKhLeCj3ei5tDqMkGWz+dlqf5NiM/1guXzwPJwXpbqv639AngxF/uUcBz3wRfyclR78mFRP4+Rz1hXbFYHcw/1MQs+d31Oj6X6NyGkt4KPd6Lm0OqelzCTR2L/YeD7Yl6+KpNHBAuP2QvXqqHIUia8FXw8ri23ukyQ5ctZWTqqezi/1AuWLwPLo1lZuv5ufQW8mIt9SjiO++AreTmqPfmoqJ/HyGesxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsKzarg7lH+pgF74X+khpLR/X/6Su9FWr2TtQcWt19zpjJY7H/KPB9NS9flcljgoXH7IVr1VBkKRPeCj7eiZpDq8sEWb6WlcVX98E/3guWrwHLE1lZuu6DfxK8mIt9SjiO++DJvBzVnnxC1M9j5DNWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWY+0vrA7mHutjlhIYHldj8dX3MNJboWbvRM2h1X3Ojpk8FftPAN/X8/JVmTwlWHjMXrhWDUWWMuGt4OOdqDm0ukyQ5ZtZWeZW38N8oxcs3wSWp7OydH0P8y3wYi72KeE47oNv5eWo9uTTon4eI5+xGquxGquxGquxGquxGquxGquxGquxGquxGquxGquxGquxGquxGquxGquxGqux5md1MPdUH7PgvSTfUGOZW91HJL0VavZO1Bxa3X0imMkzsf808H07L1+VyTOChcfshWvVUGQpE94KPt6JmkOrywRZvpuVpb26j+g7vWD5LrA8m5Wl6z6i74EXc7FPCcdxH3wvL0e1J58V9fMY+YzVWI3VWI3VWI3VWI11xWZ1MPdMH7Pge5nvqLG0V+9jpbdCzd6JmkOre5+CmTwX+88C3/fz8lWZPCdYeMxeuFYNRZYy4a3g452oObS6TJDlh3lZ5geWH/SC5YfA8nxelup97I/Ai7nYp4TjuA9+lJej2pPPi/p5jHzGaqzGaqzGaqzGmp/VwdxzfcyCrw1/oMcyv0x4K/h4J2oOre51H2byQuw/D3w/zstXZfKCYOExe+FaNRRZyoS3go93oubQ6jJBlp/kZaneF7zYC5afAMtLeVmq9wU/Ba8X40/2KeE47oOf5uWo9uRLon4eI5+xGquxGquxGqux5md1MPdCH7Pga8MX9Viq9wXSW8HHO1FzaHWv+zCTl2P/JeD7WV6+KpOXBQuP2QvXqqHIUia8FXy8EzWHVpcJsvwiL0tHYPl5L1h+ASyv5GWp3hf8EryYi31KOI774Jd5Oao9+Yqon8fIZ6wrNquDuZf7mAWfu36ux9JRJrwVfLwTNYdW97yEmbwa+68A36/y8lWZvCpYeMxeuFYNRZYy4a3g452oObS6TNg/nPfr2H8V+H6TeR0K8OHr8pi9cK0aiixlwlvBxztRc2h1mbB/OO+3sf9r4Ptd5nUowIevy2P2wrVqKLKUCW8FH+9EzaHVZcL+4bzfx/5vge8PmdehAB++Lo/ZC9eqochSJrwVfLwTNYdWlwn7h/P+GPu/B74/ZV6HAnz4ujxmL1yrhiJLmfBW8PFO1BxaXSbsH877c+z/Efj+knkdCvDh6/KYvXCtGoosZcJbwcc7UXNodZmwfzjvr7H/Z+D7W+Z1KMCHr8tj9sK1aiiylAlvBR/vRM2h1WXC/uG8v8f+X4HvH5nXoQAfvi6P2QvXqqHIUia8FXy8EzWHVpcJ+4fz/hn7fwe+f2VehwJ8+Lo8Zi9cq4YiS5nwVvDxTtQcWl0m7B/O+3fs/xP4/ifzOhTgw9flMXvhWjUUWcqEt4KPd6Lm0OoyYf9w3n9i/9/A97+Z16EAH74uj9kL16qhyFImvBV8vBM1h1aXCfs7+MX/AF9R5F2HQgB1wpi9cK2uVWQpE94KPt6JmhPDbpmwfzhvQNH9hMA3UCGTASITHg+ETJgBMxmokIn0VvDxTtQM5XVbB24DIZNBsT8A+AYrZDJIZMLjwZDJgEQmgxUykd4KPt6JmnvKZDBkslLsDwK+IQqZrCQy4fEQyIQZ8O/JEIVMpLeCj3ei5p4yGQKZDGUu4HMKmQwVmfDYQSYrJTJxCplIbwUf70TNPWXiIJNhsT8U+EqFTIaJTHhcQiZDE5mUCplIbwUf70TNPWVSQibDY38Y8I1QyGS4yITHIyCTYYlMRihkIr0VfLwTNfeUyQjIZGTsDwe+UQqZjBSZ8HgUZDI8kckohUykt4KPd6LmnjIZBZmsHPsjgW8VhUxWFpnweBXIZGQik1UUMpHeCj7eiZp7ymQVyGTV2F8Z+FZTyGRVkQmPV4NMVk5ksppCJtJbwcc7UXNPmawGmYyO/VWBb4xCJqNFJjweA5msmshkjEIm0lvBxztRc0+ZjIFMVo/90cA3ViGT1UUmPB4LmYxOZDJWIRPpreDjnai5p0zGQibjYn914BuvkMk4kQmPx0MmqycyGa+QifRW8PFO1NxTJuMhkwmxPw74JipkMkFkwuOJkMm4RCYTFTKR3go+3omae8pkImSyRuxPAL5JCpmsITLh8STIZEIik0kKmUhvBR/vRM09ZTIJMpkc+2sA3xSFTCaLTHg8BTJZI5HJFIVMpLeCj3ei5p4ymQKZtMb+ZOCbqpBJq8iEx1Mhk8mJTKYqZCK9FXy8EzX3lMlUyGRa7LcC33SFTKaJTHg8HTJpTWQyXSET6a3g452ouadMpkMma8b+NOCboZDJmiITHs+ATKYlMpmhkIn0VvDxTtTcUyYzIJOZsb8m8M1SyGSmyITHsyCTNROZzFLIRHor+Hgnau4pk1mQyezYnwl8aylkMltkwuO1IJOZiUzWUshEeiv4eCdq7imTtSCTtWN/NvCto5DJ2iITHq8DmcxOZLKOQibSW8HHO1FzT5kgy3p5War/bnLdXrCsByxz8rJU/93k+mDOXHNgH6yf2AfrK+zJOWJP8hj5jHXFZnUwt3bRtyz43LWuHkv1301KbwUf70TNodU9L2EmbWLPBL52hUzaRCY8bodM5iT2am6WMuGt4OOdqLmnTJBlblaWjur/58b3gmUusHTkXZfq79YGYM5cHbAPNkjsgw0U9mSH2JM8Rj5jNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjNVZjXbFZHczx/cF9xYL3Qns1lo62MuGtULN3oubQxPA1L5nJhmLPBL6NFDLZUGTC440gk47EXs3NUia8FXy8EzX3lAmybJKVxVf3wW/cC5ZNgGXTvOtS3Qe/GZgz16awDzZL7IPNFPbkpmJP8hj5jNVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVY+wurgzn+fLqvWPCz+I3VWHz1PYz0VqjZO1FzaGLY7XN2zGRzsWcC3xYKmWwuMuHxFpDJpom9mpulTHgr+Hgnau4pE2TZKivL3Op7mC17wbIVsHTmXZfqe5itwZy5OmEfbJ3YB1sr7MlOsSd5jHzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGmp/VwRzfX9FXLHgvyZZqLHOr+4ikt0LN3omaQxPD17xkJg2xZwLfNgqZNEQmPN4GMulM7NXcLGXCW8HHO1FzT5kgy3ZZWdqr+4i27QXLdsCyfd51qe4j2gHMmWt72Ac7JPbBDgp7cnuxJ3mMfMZqrMZqrMZqrMZqrMa6YrM6mOPX933Fgu9ltlVjaa/ex0pvhZq9EzWHJobd3qdgJjuKPRP4dlLIZEeRCY93gky2T+zV3CxlwlvBxztRc0+ZIMsueVnmB5ade8GyC7Dsmpeleh+7G5gz166wD3ZL7IPdFPbkrmJP8hj5jNVYjdVYjdVYjTU/q4O5HYu+ZcHXhjvrscwvE94KPt6JmkMTw26v+zCT3cWeCXx7KGSyu8iEx3tAJrsm9mpuljLhreDjnai5p0yQZa/M+zCw7NkLlr2AZe+8LNX7gn3AnLn2hn2wT2If7KOwJ/cWe5LHyGesxmqsxmqsxmqs+VkdzO1e9C0LvjbcU4+lel8gvRV8vBM1hyaG3V73YSb7ij0T+PZTyGRfkQmP94NM9k7s1dwsZcJbwcc7UXNPmSDLAXlZOgLL/r1gOQBYDszLUr0vOAjMmetA2AcHJfbBQQp78kCxJ3mMfMa6YrM6mNu36FsWfO7aX4+lo0x4K/h4J2oOre55CTM5WOyZwHeIQiYHi0x4fAhkcmBir+ZmKRPeCj7eiZp7yuQQyOTQ2D8Y+A5TyORQkQmPD4NMDk5kcphCJtJbwcc7UXNPmRwGmRwe+4cC3xEKmRwuMuHxEZDJoYlMjlDIRHor+Hgnau4pkyMgkyNj/3Dgm6eQyZEiEx7Pg0wOT2QyTyET6a3g452ouadM5kEmR8X+kcA3XyGTo0QmPJ4PmRyZyGS+QibSW8HHO1FzT5nMh0yOjv2jgG+BQiZHi0x4vAAyOSqRyQKFTKS3go93ouaeMlkAmRwT+0cD30KFTI4RmfB4IWRydCKThQqZSG8FH+9EzT1lshAyOTb2jwG+4xQyOVZkwuPjIJNjEpkcp5CJ9Fbw8U7U3FMmyHJ8Xpa2cM0TMtcXrrEICuJaj4c8+fgJUNsihb11vNhbPEa+N8s6pqVvWbXyP1Fhfy/qxf4+Eeo7KTPLcLrGEMj1JJEvcw4Anrcl9gY/7wwjLS7e+HvcHwTH8blqicJ+OTles4haIriC71IFX/YZHH2Zg70Gwu9cMqrr54iWrr8pPL86rM0pmRmDz7Je7L9TYL1Ozfz4CtdYDubMdSo8v/DxJcCxXCG3U8XzC4+XAws3fjworEl7XRanJljGNxHLuCZiGdtELKOaiGV4E7G4JmJZqYlYBjYRyxK95/9es4xoonUZ1kQsQ5qIZVATsSxuor07sonWpWwilqFNxDK4iViKPmZxLW98X+Dg+GL4PX6NvAzmBiSux3/XlsN7pMdHv/E62rWjTyeM2WsYMCxXfg55MyyDm4hlaBOxlE3EMrKJWBYXzcMyqInWZUgTsQxrIpYRTcSypIn27sAmWpeVmojFNRHL8CZiGdVELGObiGVcE7GMbyKWAQmW0/KydOBrdm5i2O31/2nAcnpelur7tDMyXzNc40woiGtl9hKOnwG1namQ+elF9zXlMfIZ64rNmt+3o/o3lk/vxWMcWc5SeDyeDebMdRZkcXYii7MVsjhLZMFj5DNWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzXWFZs1v+/c6v5e9A1NDF/zkizn5F2D6v7ec8Gcuc6BLM5NZHGuQhbniCx4jHzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGmp9VwXe+E76hieFrXpLlvLws1f0R54M5c50HWZyfyOJ8hSzOE1nwGPmM1ViN1ViN1ViNNT9rfl9f3Q+KvqGJYbfXO8hyQd41qF7vXAjmzHUBZHFhIosLFbK4QGTBY+QzVmM1VmM1VmM1VmM1VmM1VmM1VmM1VmM1VmM1VmPtL6z5fbv+vQH0DU0Mu32+jCwX5V2D6vPli8GcuS6CLC5OZHGxQhYXiSx4jHzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGmp9VwbfDCd/QxPA1L8lySV6W6v6IS8GcuS6BLC5NZHGpQhaXiCx4jHzGumKzKvh6J3xDq3s8IstlCo/Hy8GcuS6DLC5PZHG5QhaXiSx4jHz9hdXB3ICW1+f4+ECYuyLODYK5K+PcYJi7Cmriuavj3BCYuybODYW5a+PcOJi7Ls6dCszXx/7pMHdD7J8FczfG/jkwd1PsnwdzN8f+BTB3i/j7G+ZuFc8BYe42kWWYezv0+eftcW4YzN0Be4Ln7oxzw2Hurjg3AubujnMjYe6eODcK5u5N8HHWl8EcZ417g7O+AuY46ythjrO+CuY466thjrO+BuZ4ja6FOV6j62CO1+h6mOM1ugHmeI1uhDleo5tgjtfoZphbOc7dAnOrxLlbYW7VOHcbzK0W5zD70XHudpgbE+fugLnV49ydMDc2zt0Fc/y4uBvmxse5e2BuQpy7Fx53IaPWON8Zf7a9tVb9jZja0r3V/Y1ojT8Dy5S8LNX9tZPitaaCzxp5farn1UmiPh6zVwkMUxRZyoR3fh/fhjUPiDmOFb5h/SfG/iRgmZ63Zh9YJsD1W8GXvQbC7zwZH5jhuezk0a+fl3n/VY+F1pbure6xoLcvfLfHwpthwb0zMStLW1u45oTM1wzXmA78XCuzl3Ac90rmvVg9F0xs6b6mci8aq7Eaq7Eaq7Eaq7Eaq7Eaq7Eaq7Eaq7Eaq7Eaq7H2J1b8rL+1j1lKYND73sG3lQlvjc/L8Ts9vnb47uJQ+O5iUubawjrj9xGtwMBeA+F3rhn9OteRsT8Mjre2qLHOV1jz6rsb/g6EW933JROhvrzfbfi28J32EFjLCSIH5hwADGtmZej6fmUG1Mue7BOy5scA/56DPn7/OjMvW/WcgGydMGYv/P51uiJLmfDG7xnDOrXG+WmwdlMS65T3O8D2t/QdYO7v6wqRQyd4oG/mfdyOvkUUe/D8QOhfwDdswO+F1hp/MnPIcGLi97A/SZxTwvGJyjVPAI5OGLNX2KPLodaJCe6xwM3H8W9E5ufgihufg1uBgb3w3pZpwKLxuuP/W0N83TFNrFl+lvbqdYf0xvuDeM1CpvcBh+ZrBHkPyCTgYh7+XfkarhV+ZzycxzUqPja8fB5qbXnjYwOfD26F1zmP9vA6J/O9PR7vuZGs+Jyp+Zo73OuHHPicyb9zd1yXEZFnRuZ1cC3dn1dbWur/js2Atcn89756XTQLvJgLX3fw8THAMSsvR5XRTFE/j5HvzbJObgLWmQnW1N/bmWqsXfdNIUdodXttFrCslZWl6zXT2nD9TvBA33Xy+rajL79mYg+eHwj9z8LriHVe7772HMnMIcPZid/D/kxxTgnHZyvXvBZwdMKYvcLfgAeg1tkJ7vHAzcfxtQvn1gq1zFaoZZaoZZZgxs9MZqqxdH1mIr3xb2n+1yld9U9peb21trzxswz8jGUKcOFnLIMzc+H99NzqnlvYP9wzz/e5L122eMm8hQsOWHLcsgUFXGOQuN4AuM4AODZQ/N6QljcyZCt4DJgNiOaDYmErRfNQHN/wX8ZCwwuJcMN+uEE/3JAfbsAPN9yH+3hDPmOA9RfxZ7iBPrwYDTfIh2DDH47wwAsvlELo4Q9cCLq1petNd3jhHl7MhD804QVDeBCEjRo2aXjghye38MBfl7QeaQ5p/bAmpHaSJ80ldZA2IG1I2oi0MWkT0qakzUibk7YgbUnaKq7t1qQGaRvStqTtSNuTdiDtSNqJtDNpF9KupN1Iu5P2IO1J2ou0N2kf0r6k/Uj7kw4gHUg6iHQw6RDSoaTDSIeTjiAdSZpHOoo0n3Q0aQHpGNJC0rGk40jHk04gLSKdSDqJtJj0NtLJpCWkpaRlpFNIp5KWk04jnU46g3Qm6SzS2aRzSOeSziOdT7qAdCHpItLFpEtIl5IuI11OuoJ0Jekq0tWka0jXkq4jXU+6gXQj6SbSzaRbSLeSbiO9nXQ76Q7SnaS7SHeT7iHdS3pHS9cbpXeS3kV6N+l+0ntI7yW9j/R+0gdIHyR9iPRh0kdID5A+SnqQ9DHSx0mfIH2S9CnSp0mfIT1E+izpc6TPkx4mfYH0COmLpC+Rvkx6lPQV0mOkr5IeJ32N9ATpSdJTpK+TvkH6Julp0rdIz5C+TfoO6bukZ0nfIz1H+j7pB6Qfkp4n/Yj0AunHpBdJPyG9RPop6WXSz0g/b+l6LL1C+iXpVdKvSL8m/Yb0W9LvSL8n/YH0R9KfSH8m/YX0V9LfSH8n/YP0T9K/SP9uef0JBp9oLo7/9c3mcbxP1xNb69JFi5e1trWeRP87b9GixcsXHD2nFY8tbT3xlKXLWpcum7dkWesxSxaf2No+5/8A4yYwdWmfAwA=", "verificationKey": "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" } ] diff --git a/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json b/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json index 7b8ed831d360..2825dd0df5a2 100644 --- a/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json +++ b/yarn-project/aztec.js/src/abis/schnorr_single_key_account_contract.json @@ -7,7 +7,7 @@ "isInternal": false, "parameters": [], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -70,7 +70,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -87,7 +87,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -149,6 +149,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -195,6 +201,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -220,6 +232,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -231,7 +249,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -241,7 +280,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -251,7 +305,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -261,7 +336,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -341,7 +431,7 @@ ] } ], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/+2dB5wdVdnG7+ymTU4KJQkthCWQQt+dLDWUDRcCRERARFREQmgiTRKw996xi4CAiIiAgIiISG/SmzTpTbqIiCiW73vf2fOYh8MwH/vjnG9nzXt+v4d7ys55/u975s6de++54Z+tVitr9ZdO0YTWKwvG+/xj9+srPVm8ubpTcnYMEc7OIcI5bIhwDh8inCOGCOfIIcI5aohw5kOEc/QQ4XRDhHPMEOEcO0Q4xw0RzvFDhHOpIcK59BDhXGaIcC47RDgnRORcgTgn+sdJ/nE5/7i8f8TfrugfV/KPk32Mw3x7ZdEU0SqiLj/W58dWFU0VrSZaXTRNNF00QzRTtIZoTdFaorVF64jWFa2nsYp6RIVolqhXtL5oA9GGoo1EG4s2Ec0WbSraTLS5aAvPMEe0pagt2kq0tWiuaBvRtqLtRPNEbxBtL3qjaAfRm0Q7inYS7Sx6s2gX0VtEu4reKtpN9DbR20XvEO0ueqdoD9G7RHv6XODkmC/aS7RAtLdoH9G+ov1E+4veLTpA9B7RgaKDRAeLDhEdKnqv6DDRQtEi0eGiI0TvE71f9AHRB0UfEn1Y9BHRR0UfE31c9AnRJ0WfEn1a9BnRZ0WfE31e9AXRF0VfEn1Z9BXRV0VfEx3pYxnjY/m66Buib4q+Jfq26Dui74q+JzpK9H3R0aJj/LFd/thjRT8QHSc6XnSC6IeiE0U/Ep0k+rHoZNFPRKeIfio6VXSa6HTRz0RniM4UnSX6uehs0S9E54h+KTpX9CvReaJfi84X/SZYkwtEF4ouEl0sukR0qegy0eWiK0RXiq4S/VZ0tega0bWi60TXi24Q3Si6SXSz6BbRraLfiW4T3S66Q3Sn6C7R70V3i+4R3Su6T3S/6AHRg6KHRA+LHhE9KvqD6DHR46InRE+KnhI93Xr58/AZ0R9Fz4r+5Mc6/Nhzoj/7+vP+8S/+8QX/+Ff/+KJ//Jt//Lt/fMk//qO1uIxZuv9R7+1xPVm2tbgPn8ssQ30YX5r6ML4U9WF8PPVhfBz1YXws9WF8DPVh3FEfxkdTH4/jEeOjqA/jI6kP4yOoD+PDqQ/jw6gP453Uh/EO6sN4Rn0YbwX+Wvr8Y/frLCNa0V/bujXmHoqjVREvf84XxjusIi/DK/LH64FxXjeM8/ryOB4xzucLxvm8wTiffxjn8xTjfD5jnM97jPPzA+P8PMI4P98wzs9LjE+gPoxPpD6MT6I+jC9HfRhfnvowvgL1YRz3FBqX5n6yb/f5x+7XVwr1wv0KSha0+6gOf2WZkoBl5QGwTCGWVeKylJ/BdPm5ViKfVSP78Os95kUbXo4YVknI4iq8U/hwblHq1plZpsZlKW9vViOvLv84lXKP8YnEsVrknGTkiXnRhldOfSsPMosjhi7qw9+tmo6vyAM+LXXnz2rEMi0qS0+3sqw+AJZpxDI9Kkv/fceMyHPqHDOJH7GC3dH4DIptZlyO8pyc3np5TtFmPmM1VmM1VmM1VmM1VmNdsllz6ps6yCz8/mj1ZCw93a7CO8X7Df48C3Pr54jHkGdX5Ng0z6sG84MBXp30Ny+NX8x1vO8bTeNTk7EWC1J9RobPgFBe62dkK0deC/1MdiTlMvw8AJwdxLBSVIZXfn4DT/joWuMzS/4cBZ+5YkzPj9OIsymfs/Jnovw5ZOTzqrx+rRywoA0v/hyyIyGLq/Bu0ufN/Bzkz+G6Iucha738ud5HbXhxrjoTsrgK7wQ+A76+dflHPQ7XIf6MPPLnxT38+oN5w9cSztWwhCyuVf06FtmnyIOYtdStCfz1OFxz+TV79ch5yFovfw3ooza8OFfDE7K4Cu8EPkUexKylbk3gr8fhM2j+XDzyvWG5JtMCFrT5fQIzpGJxFd4JfIo8iFlL3ZrAX4/D+yT+fiDFe5QZAQva/B4FDCMTsrgK7wQ+RR7ErKVuTfh94xq+zu9h14ych4x8MC/a8OJcjUrI4iq8E/gUeRCzlro1gb8et5avr0F8a0fOQ0Y+mBdteHGu8oQsrsI7gU+RBzFrqVuTtSn2dXx9LeJbN3IeMvLBvGjDi3M1OiGLq/BO4FPkQcxa6tYE/nrcer6+DvF1R85DRj6YF214ca5cQhZX4Z3Ap8iDmLXUrQn89Tjs31uP+IrIecjIB/OiXdA6gGFMQhZX4Z3Ap8iDmLXUrQn89bhZvt5DfL2R85CRD+ZFG16cq7EJWVyFdwKfIg9i1lK3JvDX49b39VnEt0HkPGTkg3nRhhfnalxCFlfhncCnyIOYtdStCfz1uA19fX3i2yhyHjLywbxow4tzNT4hi6vwTuBT5EHMWurWBP563Ma+viHxbRI5Dxn5YF604cW5Wiohi6vwTuBT5EHMWurWBP563Gxf35j4No2ch4x8MC/a8OJcLZ2QxVV4J/Ap8iBmLXVrAn89bjNfn018m0fOQ0Y+mBdteHGulknI4iq8E/gUeRCzlro1gb8et4Wvb0Z8fZHzkJEP5t0i8OBcLZuQxVV4J/ApOLcodWuCuh43x9e3IL4tI+chIx/Miza8OFcTErK4Cu8EPkUexKylbk2YpR2XpdyzsZWfaw75bB05txn5YF604cX5bydkcRXeCXyKPIhZS906w1+Pm+vrWxHfNpHzkJEP5kUbXpyr5RKyuArvBD5FHsSspW5NmGW7uCy9yrLtAFi2I5Z5cVnKj6XeQF7ggo+jcX5uviEuR3lOzgviR5v5jHXJZs2pb+4gs/C1a9t0LL2uwjuBT5EHMWupuy7xmmzv6/OI741x+co12T5gQRtenKt2QhZX4Z3Ap8iDmLXUrQmzvCkqS295z7jDAFjeRCw7RmXpf93aibzABR9H43we7BSXozwndwziR5v5jNVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjdVYjXXJZs2pb/tBZuG90DskY+kt/z3j0DtBzEUexKylbp8zr8nOvr4j8b05Ll+5JjsHLGjDi3PVTsjiKrwT+BR5ELOWujVhlrdEZZlV7oPfZQAsbyGWXaOy9O+Dfyt5gQs+jsb5PHhrXI7ynNw1iB9t5jNWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzVWYzXW+Kw59e08yCy8l2SXZCyzyn1EoXeCmIs8iFlL3T4RXpPdfH1X4ntbXL5yTXYLWNCGF+eqnZDFVXgn8CnyIGYtdWvCLO+Iy7JAWd4+AJZ3EMvucVnKfUTvJC9wwcfROJ8H74zLUZ6Tuwfxo818xmqsxmqsxmqsxhqfNae+3QaZhe8N356OZYGr8E7gU+RBzFrq7vt4Tfbw9d2J711x+co12SNgQRtenKt2QhZX4Z3Ap8iDmLXUrQmzzI/KUpS/L9hzACzziWWvqCz97wsWkNee/hE+jsb5PFgQl6M8J/cK4keb+YzVWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWIcKa059ewwyC38Wv2cylqLcnxV6J4i5yIOYtdR9zs5rsrev70V8+8TlK9dk74AFbXhxrtoJWVyFdwKfIg9i1lK3JsyyX1SW/n/nad8BsOxHLPtHZen/Hubd5AUu+Dga5/Pg3XE5ynNy/yB+tJnPWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWOOz5tS39yCz8F6SfZOx9P87T6F3gpiLPIhZS90+EV6TA3x9f+J7T1y+ck0OCFjQhhfnqp2QxVV4J/Ap8iBmLXVrwiwHxWXpVZYDB8ByELEcHJel3Ed0CHmBCz6Oxvk8OCQuR3lOHhzEjzbzGeuSzZpT3wGDzMLXrgPTsfS6Cu8EPkUexKyl7rrEa3Korx9MfO+Ny1euyaEBC9rw4ly1E7K4Cu8EPkUexKylbk2YZWEClsMGwLKQWBbFZSlftw4nL3DBx9E4nweHx+Uoz8lFQfxoM99QYc2p79BBZuHn2GHpWApX4Z3CJw9i1lL3/OE1OcLXFxHf++LylWtyRMCCNrw4V+2ELK7CO4FPkQcxa6lbE/jrce/39SOI7wOR85CRD+ZFG16cq3ZCFlfhncCnyIOYtdStCfz1uA/6+vuJ70OR85CRD+ZFG16cqzwhi6vwTuBT5EHMWurW5EMU+4d9/YPE95HIecjIB/OiDS/O1eiELK7CO4FPkQcxa6lbE/jrcR/19Q8T38ci5yEjH8yLNrw4Vy4hi6vwTuBT5EHMWurWBP563Md9/aPE94nIecjIB/OiDS/O1ZiELK7CO4FPwblFqVsT+Otxn/T1jxPfpyLnISMfzIs2vDhXYxOyuArvBD5FHsSspW5N4K/HfdrXP0l8n4mch4x8MC/a8OJcjUvI4iq8E/gUeRCzlro1gb8e91lf/zTxfS5yHjLywbxow4tzNT4hi6vwTuBT5EHMWurWBP563Od9/bPE94XIecjIB/OiDS/OVTshi6vwTuBT5EHMWurWBP563Bd9/fPE96XIecjIB/OiDS/OVTshi6vwTuBT5EHMWurWBP563Jd9/YvE95XIecjIB/OiDS/OVTshi6vwTuBT5EHMWurWBP563Fd9/cvE97XIecjIB/OiDS/OVTshi6vwTuBT5EHMWurWhFmOjMtS/nsaX/dzfZV8vhE5txn5YF604cX5PzIhi6vwTuBT5EHMWurWGf563Dd9/evE963IecjIB/OiDS/O1ZEJWVyFdwKfIg9i1lK3JvDX477t698kvu9EzkNGPpgXbXhxro5MyOIqvBP4FHkQs5a6NYG/HvddX/828X0vch4y8sG8aMOLc9VOyOIqvBP4FHkQs5a6NYG/HneUr3+X+L4fOQ8Z+WBetOHFuWonZHEV3gl8ijyIWUvdmsBfjzva148ivmMi5yEjH8yLNrw4V+2ELK7CO4FPkQcxa6lbE/jrccf6+tHE94PIecjIB/OiDS/OVTshi6vwTuBT5EHMWurWBP563HG+fizxHR85Dxn5YF604cW5aidkcRXeCXwKzi1K3Zoc7x/1uBN8/Tji+2HkPGTkg3nRhhfnqp2QxVV4J/Ap8iBmLXVrAn897kRfP4H4fhQ5Dxn5YF604cW5aidkcRXeCXyKPIhZS92awF+PO8nXTyS+H0fOQ0Y+mBdteHGu2glZXIV3Ap8iD2LWUrcm8NfjTvb1k4jvJ5HzkJEP5kUbXpyrdkIWV+GdwKfIg5i11K0J/PW4U3z9ZOL7aeQ8ZOSDedGGF+eqnZDFVXgn8CnyIGYtdWsCfz3uVF8/hfhOi5yHjHwwL9rw4ly1E7K4Cu8EPkUexKylbk3gr8ed7uunEt/PIuchIx/Miza8OFfthCyuwjuBT5EHMWupWxP463Fn+PrpxHdm5Dxk5IN50YYX56qdkMVVeCfwKfIgZi11awJ/Pe4sXz+D+H4eOQ8Z+WBetOHFuWonZHEV3gl8ijyIWUvdmsBfjzvb188ivl9EzkNGPpgXbXhxrtoJWVyFdwKfIg9i1lK3JvDX487x9bOJ75eR85CRD+ZFG16cq3ZCFlfhncCnyIOYtdStCfz1uHN9/Rzi+1XkPGTkg3nRhhfnqp2QxVV4J/Ap8iBmLXVrAn897jxfP5f4fh05Dxn5YF604cW5aidkcRXeCXyKPIhZS92awF+PO9/XzyO+30TOQ0Y+mBdteHGu2glZXIV3Ap8iD2LWUrcmzHJhXJby34S4YAAsFxLLRXFZyt/WXkxe4IKPo3E+Dy6Oy1GekxcF8aN9MfUb65LNmlPf+YPMwteuC9KxlP8mROidwKfg3KLUXZcu9o963CW+fhHxXRqXr1yTSwIWtOHFuWonZHEV3gl8ijyIWUvdmjDL5VFZess9nJcNgOVyYrkiKkv/69aV5AUu+Dga5/Pgyrgc5Tl5RRA/2sxnrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrMZqrEs2a059lwwyC++FviwZS2/5//QNvRPEXORBzFrq9jnzmlzl61cQ32/j8pVrclXAgja8OFfthCyuwjuBT5EHMWupWxNmuSYqS1Hug796ACzXEMu1UVn698FfR17ggo+jcT4ProvLUZ6T1wbxo818xmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsQ4U1p76rBpnFEcPVyViK8nuY0DtBzEUexKyl7nN2XpPrff1a4rshLl+5JtcHLGjDi3PVTsjiKrwT+BR5ELOWujVhlpuisswqv4e5cQAsNxHLzVFZ+r+HuYW8wAUfR+N8HtwSl6M8J28O4keb+YzVWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI3VWI01PmtOfdcPMgvvJbkxGcusch9R6J0g5iIPYtZSt0+E1+RWX7+Z+H4Xl69ck1sDFrThxblqJ2RxFd4JfIo8iFlL3Zowy+1RWXrKfUS3DYDldmK5IypL/z6iO8kLXPBxNM7nwZ1xOcpz8o4gfrSZz1iN1ViN1ViN1ViN1ViXbNac+m4dZBZ+L3NbMpae8n1s6J0g5iIPYtZS9z6F1+QuX7+D+H4fl69ck7sCFrThxblqJ2RxFd4JfIo8iFlL3Zowyz1xWRYoy90DYLmHWO6Ny1K+j72PvMAFH0fjfB7cF5ejPCfvDeJHm/mM1ViN1ViN1ViNNT5rTn13DTIL3xvenY5lgavwTuBT5EHMWuru+3hN7vf1e4nvgbh85ZrcH7CgDS/OVTshi6vwTuBTcG5R6tbkAWJ5KC5L+b7gwQGwPEQsD8dlKd8XPEJe4IKPo3E+Dx6Jy1Gekw8H8aPNfMZqrMZqrMZqrMYanzWnvvsHmYXvDR9Mx1K+Lwi9E/gUeRCzlrr7Pl6TR339YeL7Q1y+ck0eDVjQhhfnqp2QxVV4J/Ap8iBmLXVrwiyPx2XpVZbHBsDyOLE8EZelfF/wJHmBCz6Oxvk8eDIuR3lOPhHEjzbzGeuSzZpT36ODzMLXrsfSsfS6Cu8EPkUexKyl7rrEa/KUrz9BfE/H5SvX5KmABW14ca7aCVlchXcCnyIPYtZStybw1+Oe8fWniO+PkfOQkQ/mRRtenKt2QhZX4Z3Ap8iDmLXUrQn89bhnff0Z4vtT5Dxk5IN50YYX56qdkMVVeCfwKfIgZi11awJ/Pe45X3+W+P4cOQ8Z+WBetOHFuWonZHEV3gl8ijyIWUvdmsBfj3ve158jvr9EzkNGPpgXbXhxrtoJWVyFdwKfIg9i1lK3JvDX417w9eeJ76+R85CRD+ZFG16cq3ZCFlfhncCnyIOYtdStCfz1uBd9/QXi+1vkPGTkg3nRhhfnqp2QxVV4J/Ap8iBmLXVrAn897u++/iLxvRQ5Dxn5YF604cW5aidkcRXeCXyKPIhZS92aMMs/4rJ065z/jJxHneNfxI9Ywe5o/J8U278ic2TkiXnRZr7XyjpxkFlTrf+/485Znt+cUy115/e/Kb7/icwyRuYY2Vq8rpg/zG0HsxIsxnHdGU3B8N+hPozG+VrVmUWNqzxfOsDh1Rlwqe+wBL7wGe59wQGvTvqbM0f3P45t9T+XWkG+U+WGSx/V4cUsKzaIZbkGsbSy5rAs36C8TGoQy7wGsUxsEMv4BrGMaRBL3iCWEQ1i6WwQywoNYhnbIJbRDWIZ2SCWYQ1imdsglnENYnENYhnVIJbhDWLJBpklb73yfXJO4y36u47gWM3jsKUXjw/3/R0V8wzPXvl3HPuIBLGzTx+14TWaGP4zNogswxvEMqpBLK5BLOMaxDK3QSzDGsQyskEsoxvEMrZBLCs0iKWzQSwjGsSSN4hlTINYxjeIZWKDWOY1iGVSg1iWbxALbnibwLJcg/KyYoNYOipYRsZlKX+7MMrPqQXv00bya5GvjyKOPDJHFnBk5AsvfX3G3+zk3wzo/eYOvq5c2/VXo3Hpax+et5hbPXdJ4LnPRhvM36t3331fi+e2ceMsvzeHF0oWtPuoDn9l2SYuS7kvYOu4c5b7QrYifsQKdkfjW1NsW0XmyMgT86LNfK+VdeIgs6Za/3bcOcvzm3Oqpe785v0TW0Zmwb4QrCvmD3PL+xT64jKU1/0tKN7w3NHr/hxf579DfRiN9xHnZnE5y3Nwcz9X5rVZwKK+mybwhQ/2moADXp30N+/11+a6vSYpcsOlj+rwerW9JoPNslyDWJZvEMukBrHMaxDLMg1iGd8gljENYskbxDKiQSydDWJZoUEscxrEsmyDWJZqEMvYBrGMbhDLyAaxDGsQy9wGsUxoEMvSDWIZ1yAW1yCWUQ1iGd4glmyQWV5tbxLG51BfR3BsuDdptu/vqJhnduuVf8exb5Igdvbpoza8eG/S7AawDG8Qy6gGsbgGsYxrEMvSDWKZ0CCWuQ1iGdYglpENYhndIJaxDWJZqkEsyzaIZU6DWFZoEEtng1hGNIglbxDLmAaxjG8QyzINYpnXIJZJDWJZvkEsyzWIZcUGsXRUsGwcl6Xc07BRa3HB+/qNiQNMGxHHhpE5soAjI194ddLfrOkvvnofPmPMYq4Ue9lwX8D7ytZJ4Ml72f4vz8h72XqbtJdN59iavKr2cmGcv5uLvf+tbi/X1ul8y/j/G/fdGetrZ82pb+4gszhi2C4dS/nvTf8/7JXs4X2NvF8n8v7JMrdbBblFu025BcM2CVlchXcCn94G7Rktr6NzyAtcW1LuMc6vI3PicpTnwZZB/Ggz32tl3dpY/ytZ4/v2lvev7Kul7vnILH1RWV65fzp8vjsa57XYIi5HT9Z6ecx91K7at22sxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsSyZrfN9Z5f5e9tVSt7+XWTaPytK/v3ezCl/4OBrntUj57x9jXrSZz1iN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1ViN1VjjsybwXZAHvlrq9kcwS+T/P3K5P2I2eYELPo7GeS1mx+Uo12LTIH60mc9YjdVYjdVYjdVY47PG9y3K/aDsq6Xufifh/+eivN/ZmLzABR9H47wWkf8fF+VabBLEjzbzGauxGquxGquxGquxGquxGquxGquxGquxGquxGquxDhXW+L79/94A+2qp+3yZWTaKytL/+fKG5BX+f4odjfNaRP5/F5drsVEQP9rMZ6zGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzGaqzxWRP49uaBr5a6/RHMskFclnJ/xPrkBS74OBrntVg/Lke5FhsE8aPNfMa6ZLMm8C3ywFdL3fORWXrjspTPx1nkBS74OBrntZgVl6Nci94gfrSZb6iw5tTXQX0Y76S+wteHUV+Prw+nvm6KCX3r+fpI6lvX10dR3zq+vhz1re3rW1HfWr6+JfWt2VocJ/rW8PXNqW+mr29KfTN8fRPqm+7rG1HfNF/fgPpW9/WtqW81quNxqq+Ppr5Vfd1RX5evj6G+VXx9LPVN8fVx1Leyr4+nvskVfFjrXurDWvO5gbUuqA9r3UN9WOtu6sNar0d9WOt1qQ85Wof6kKO1qQ85Wov6kKM1qQ85WoP6kKOZ1IcczaC+pXx9OvUt7evTqG8ZX1+d+pb1dV77Cb4+lfom+vqq1DfJ17uoD8+BVahveV+fQn0r+PrK1Leir2PtdS1G0Px9/rH79ZWCz2GUuteILv84guKKxNLNz4lVyWfluD7ldXVKEN+UYA0cMaySkMVVeMf3Kbo55g6/jpMCX77WTCGW1SLHrCwr0fxd5AuvTvob55/Uei07a6nFx0U+/wq+dqPUPRfSnRfFy54Lr4WFz53JUVm6u3XOlSLPqXOsRvyIFeyOxvlcSXEuTm69PKfhuWisxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxmqsxjqUWPmz/q5BZnHEkO57h6LbVXin+Ly86vs7/e7iGPruYkrk2DTP/H1EFzHAq5P+5gb6TuV4Xx9N412tZKwLEuS84O/OUeq+L5lM8cX9bqPo1u+0R1IuVwrWAZwdxLB6VIb+71emLQ73P57w0bXGc4C/F0edv3+dHpetvCYwWx+14cXfv66WkMVVePP3jJqnLt/P+z9WqchT3O8Ae17Xd4Cxv6/LgnXoIw/2jXwe97Bv5gUP9HdS/VJsAKG/09LlH8Gsazi54u+4PiU4xtH45MQxr0QcfdSGl56j51Kskyu4JxE3xvk1IvI1uOTma3AXMcArp1imEkuK+45XyyHfd0wNchafpae87wi9ec8QclbeIxBHynuEcA8I70cCD/42vIfror9ZkY5DjKmfG3wd6mq98rnB14M76D4HG8Fe7T4n5T6jkJWvmSnvuXWvH3PwNRN/c5/P0VjPMy0yD++xRKl7HZtGuYn8el/eF80gL3DxfQfGJxLHjMg5ycgT86LNfNMrWKtew6YnY+3fi8QcWurWbwaxrBGVpf8+ZE2av4882HetuL497Iv7EHigv5PqL9Jr81qLq/+57oBZ13Bmxd9xfXpwjKPxmYljXoM4+qgNL72uPk2xzqzgXpG4Mc73A1i3LoplZoJYZgSxzAiY+XOI6clY+j+HCL359Sn+a39//Dj3kOvw8wH+3GIV4uLPLTojc+mcwyPPyfveUequV/DXve3Yo75w0SGHzd9vn533mb93RlMMC6broGm43kkpHUGpRB+/9dcysvVKxGj5mEDQHR5umI97hDcf1Vq8b19zoJ9h6P2A7rvXffZ6CujpqfvmdZ/8BOJ8zD/q66XeT+q+d93nrvva9XzS1yt9vus9j55rem51tfrfO+v9t96T6Gubvu7r806fG/q80GuNXk/1WqO/I9DfF+jvDvT3CPpCrr9f0N816O8d9HcQ+vsl/V2H/q5Qf/Oh//6y/h5kdqv/tyL6/zfeXLSFz+2cVv/vT9qt/t+m6O8r5oq2EW0r2k40T/QG0faiN4p2EL1JtKNoJ9HOojeLdhG9RbSr6K2i3URvE71d9A7R7qJ3ivYQvUu0p2i+aC/RAtHeon1E+4r2E+0verfoANF7RAeKDhIdLDpEdKjovaLDRAtFi0SHi44QvU/0ftEHRB8UfUj0YdFHRB8VfUz0cdEnRJ8UfUr0adFnRJ8VfU70edEXRF8UfUn0ZdFXRF8VfU10pOjrom+Ivin6lujbou+Iviv6nugo0fdFR7f639ccK/qB6DjR8aITRD8UnSj6kegk0Y9FJ4t+IjpF9FPRqaLTRKeLfiY6Q3Sm6CzRz0Vni34hOkf0S9G5ol+JzhP9WnS+6DeiC0QXii4SXSy6RHSp6DLR5aIrRFeKrhL9VnS16BrRtaLrRNeLbhDdKLpJdLPoFtGtot+JbhPdLrpDdKfoLtHvRXeL7hHdK7pPdL/oAdGDoodED4seET0q+kOr//n0uOgJ0ZOip0RPi54R/VH0rOhPoudEfxY9L/qL6AXRX0Uviv4m+rvoJdE/WosvOHyROcP/SGdT335z/zWva+GBhyzq6u46WP47/8ADD3nfPnuv28VjC7sOOnzhoq6Fi+Yftqhr38MOOairZ12e91AXb97/BVtSZBPQ+wIA", "verificationKey": "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" }, { @@ -410,6 +500,12 @@ "type": { "kind": "boolean" } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -456,6 +552,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -481,6 +583,12 @@ "type": { "kind": "field" } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } } ] } @@ -492,7 +600,28 @@ "kind": "array", "length": 4, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectWithRange", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "start_side_effect_counter", + "type": { + "kind": "field" + } + }, + { + "name": "end_side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -502,7 +631,22 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -512,7 +656,28 @@ "kind": "array", "length": 16, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffectLinkedToNoteHash", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "note_hash", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -522,7 +687,22 @@ "kind": "array", "length": 2, "type": { - "kind": "field" + "kind": "struct", + "path": "aztec::abi::SideEffect", + "fields": [ + { + "name": "value", + "type": { + "kind": "field" + } + }, + { + "name": "side_effect_counter", + "type": { + "kind": "field" + } + } + ] } } }, @@ -602,7 +782,7 @@ ] } ], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/+2dCZhcRdWG+84kmVQqG4HsJOkkZGELMzcjIiKOjcgmm2yyCSGsskSSIAIiICIiIIiIiIiACIiIiICIbLJvsskmm2yyi4iIyPLzn7pTH/lS3P/+jFQ90/Pk1PN8di1z63vPObe7b3df4ju1Wi2rdbdW0cja+xvWu/xj+4drHVm8vdpTcrb0Ec7WPsLZr49w9u8jnAP6CGdbH+Ec2Ec4TR/hHNRHOG0f4RzcRziH9BHOoX2Ec1gf4RzeRziX6iOcI/oI59J9hHOZPsI5MiLnWOIc5R9H+8cx/hF/M84/jvePy/rHCT7Gfn48UTRJVBdN9mtdfm2KaKpoOdE00XTRDNFM0fKiFUQrilYSrSyaJVrFxSnqEOWi2aJO0UdEq4o+KlpN9DHR6qKPi9YQfUK0puiT3v9TooZoLdGnRWuLPiNaR7SuaD3R+qINRJ8VbSjaSLSxaBPRpqLPiTYTbS7aQrSlaCvR50Vbi7YRbSvaTrS96AuiHUQ7iub4XODk2Ek0V7SzaBfRrqLdRLuL9hB9UbSnaC/R3qJ9RPNEXxLtK5ovWiBaKNpP9GXR/qKviA4QHSg6SPRV0cGir4kOER0qOkz0ddHhom+IjhB9U3Sk6Fuio0TfFh0tOkZ0rOg7ouNEx4u+62MZ7GM5QfQ90Ymi74tOEv1AdLLoh6JTRD8SnSr6sT+27o89TfQT0emiM0Rnin4qOkv0M9HZonNE54p+LjpP9AvR+aJfii4Q/Up0oejXootEvxFdLLpEdKnot6LLRL8TXS76vegK0ZVBTa4SXS26RvQH0bWi60TXi24Q3Si6SXSz6BbRraLbRLeL/ii6Q3Sn6C7R3aJ7RH8S3Su6T3S/6AHRg6I/ix4SPSx6RPSo6DHRX0SPi54QPSl6SvS06K+iZ0TPip4TPS96QfSi6CXR32qLPw9fFv1d9IroH36txa+9Kvqn77/mH//lH1/3j//2j2/4x//4xzf941v+8e3aovbOsO5H9xkEryfL1BbN4fujpWkO6yNoDutL0RzWh9Mc1ofRHNaH0hzWh9Ac1gfTHNYtzWF9EM3xOh6xPpDmsN5Gc1gfQHNY709zWO9Hc1hvpTmst9Ac1jOaw3ot8Hetyz+2f8g2oBb9/a7dxZxTHLWSePk7yjDefiV56V+SP64H1rluWOf68joesc7nC9b5vME6n39Y5/MU63w+Y53Pe6zz8wPr/DzCOj/fsM7PS6zz8xfrI2kO66NoDuujaQ7rY2gO62NpDuu43nBxudzjuqPLP7Z/uJYb8kDLgnEX9eHvWCYkYFm2BywTKF8TfX8U8U1KwFf3e40jn8lxfTr4ugD7YgwvSwyTErLYEu8EPovlFq2q9swyJS5LcRk0lbzq/nEK5R7rI4ljauTcZ+SJfTFmvg/KOrGXWQ3NLdvLLJYY6jSHv5ucji83AZ9rVef6VGKZFpWlo92xLNcDlmnEMj0qS/d104zIe7o9ZhI/YgW7pfUZFNvMuBzFOTm9tnhOMWY+ZVVWZVVWZVVWZVVWZV2yWQ3NTellFv58tFwylo52W+Kd4vMGf/eGvd33oGeSZz1ybC7Pk4P9wQCvVvqbF4Yu4jrbzw2i9SnJWPO5bs+JUffs/uyL76vQqj5v8ncWcb9v7Gh33ym3US4nBHUAZwsxRP7+tfh8yt+/whM+rtb4ngJ/x98PY82dHxel4/yvvyc2Jfzxa9n9+rVswMK/zbvG35m2JGSxJd7N+n05fw8X+fvyoiYTAxaM4cW5ak3IYku8U/1GwDG7VlUT+PP33/ya11u/LYChX0KWZv9tgb+nrRNfb31fDYb+CVlsiXczfQfO31fztU/c78W7a7JcwIIxvGzAkIrFlngn8Mn/298C+DMKfy6I/F1+5WcUeHGu2hKy2BLvBD65CWJ2raom8HfH4bPTdOJbPnIestrin6W7aAwvztXAhCy2xDuBT26CmF2rqgn83XEr+D5/rl0xch4y8sG+GMOLc2USstgS7wQ+uQlidq2qJitS7Cv5/grEt3LkPGTkg30xhhfnalBCFlvincAnN0HMrlXVBP7uuFm+vxLxrRI5Dxn5YF+M4cW5sglZbIl3Ap/cBDG7VlUT+LvjcH/wLOLriJwHvg8Z+2LcQXUAw+CELLbEO4FPboKYXauqCfzdcbgntJ34ZkfOQ0Y+2BdjeHGuhiRksSXeCXxyE8TsWlVN4O+O6/T9nPg+EjkPGflgX4zhxbkampDFlngn8MlNELNrVTWBvztuVd/vJL6PRs5DRj7YF2N4ca6GJWSxJd4JfHITxOxaVU3g745bzfdXJb6PRc5DRj7YF2N4ca6GJ2SxJd4JfHITxOxaVU3g745b3fdXI76PR85DRj7YF2N4ca6WSshiS7wT+OQmiNm1qprA3x23hu+vTnyfiJyHjHywL8bw4lyNSMhiS7wT+OQmiNm1qprA3x23pu+vQXyfjJyHjHywL8bw4lwtnZDFlngn8MlNELNrVTWBP/97H2sS36ci5yEL/LtoDC/O1TIJWWyJdwKfnHOLVlUTZmnEZSnu2Vgr2NP5fDpybjPywb4Yw4vz30jIYku8E/jkJojZtao6w98dt7bvr0V8n4mch4x8sC/G8OJcjUnIYku8E/jkJojZtaqaMMu6cVk6Hcs6PWBZl1jWi8tSfNWwPnmBCz6W1vm5uX5cjuKcXC+IH2PmU9Ylm9XQ3Nq9zMKvXeukY+m0Jd4JfHITxOxa1esS12QD31+P+D4bl6+oyQYBC8bw4lw1ErLYEu8EPrkJYnatqibMslFUls7imnHDHrBsRCwbR2Xpft/ahLzABR9L63webBKXozgnNw7ix5j5lFVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlXXJZjU0t0Evs/C90BsmY+ks/j3j0DtBzLkJYnat6j5nrsmmvr8x8X0uLl9Rk00DFozhxblqJGSxJd4JfHITxOxaVU2YZfOoLLOL++A36wHL5sSyRVSW7vvgtyQvcMHH0jqfB1vG5SjOyS2C+DFmPmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmWNz2pobtNeZuF7STZLxjK7uI8o9E4Qc26CmF2ruk+Ea7KV729BfJ+Py1fUZKuABWN4ca4aCVlsiXcCn9wEMbtWVRNm2SYuy1zHsnUPWLYhlm3jshT3EW1HXuCCj6V1Pg+2i8tRnJPbBvFjzHzKqqzKqqzKqqzKGp/V0NxWvczC14Zbp2OZa0u8E/jkJojZtarrPq7J9r6/LfF9IS5fUZPtAxaM4cW5aiRksSXeCXxyE8TsWlVNmGXHqCx58d8X7NADlh2JZU5Ulu7PBTuRF7jgY2mdz4Od4nIU5+ScIH6MmU9ZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlbWvsBqa276XWfi7+B2SseTF/Vmhd4KYcxPE7FoWjLuozzWZ6/tziG/nuHxFTeYGLBjDi3PVSMhiS7wT+OQmiNm1qpowy65RWbr/naddesCyK7HsFpWl+3eY3ckLXPCxtM7nwe5xOYpzcrcgfoyZT1mVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVnjsxqam9vLLHwvyS7JWLr/nafQO0HMuQlidq3qPhGuyR6+vxvxfTEuX1GTPQIWjOHFuWokZLEl3gl8chPE7FpVTZhlr7gsnY5lzx6w7EUse8dlKe4j2oe8wAUfS+t8HuwTl6M4J/cO4seY+ZR1yWY1NLdHL7Pwa9ee6Vg6bYl3Ap/cBDG7VvW6xDWZ5/t7E9+X4vIVNZkXsGAML85VIyGLLfFO4JObIGbXqmrCLPMTsOzbA5b5xLIgLkvxvrWQvMAFH0vrfB4sjMtRnJMLgvgxZr6+wmpobl4vs/BzbN90LLkt8U7hY4KYXat6/nBN9vP9BcT35bh8RU32C1gwhhfnqpGQxZZ4J/DJTRCza1U1gb87bn/f34/4vhI5Dxn5YF+M4cW5aiRksSXeCXxyE8TsWlVN4O+OO8D39ye+AyPnISMf7IsxvDhXJiGLLfFO4JObIGbXqmpyIMV+kO8fQHxfjZyHjHywL8bw4lwNSshiS7wT+OQmiNm1qprA3x13sO8fRHxfi5yHjHywL8bw4lzZhCy2xDuBT26CmF2rqgn83XGH+P7BxHdo5Dxk5IN9MT6U6gCGwQlZbIl3Ap+cc4tWVZND/aM77jDfP4T4vh45Dxn5YF+M4cW5GpKQxZZ4J/DJTRCza1U1gb877nDfP4z4vhE5Dxn5YF+M4cW5GpqQxZZ4J/DJTRCza1U1gb877gjfP5z4vhk5Dxn5YF+M4cW5GpaQxZZ4J/DJTRCza1U1gb877kjfP4L4vhU5Dxn5YF+M4cW5aiRksSXeCXxyE8TsWlVN4O+OO8r3jyS+b0fOQ0Y+2BdjeHGuGglZbIl3Ap/cBDG7VlUT+Lvjjvb9o4jvmMh5yMgH+2IML85VIyGLLfFO4JObIGbXqmoCf3fcsb5/NPF9J3IeMvLBvhjDi3PVSMhiS7wT+OQmiNm1qpowy3FxWYp/T+N4v9ex5PPdyLnNyAf7Ygwvzv9xCVlsiXcCn9wEMbtWVWf4u+NO8P3jie97kfOQkQ/2xRhenKvjErLYEu8EPrkJYnatqibwd8ed6PsnEN/3I+chIx/sizG8OFfHJWSxJd4JfHITxOxaVU3g7447yfdPJL4fRM5DRj7YF2N4ca4aCVlsiXcCn9wEMbtWVRP4u+NO9v2TiO+HkfOQkQ/2xRhenKtGQhZb4p3AJzdBzK5V1QT+7rhTfP9k4vtR5Dxk5IN9MYYX56qRkMWWeCfwyU0Qs2tVNYG/O+5U3z+F+H4cOQ8Z+WBfjOHFuWokZLEl3gl8chPE7FpVTeDvjjvN908lvp9EzkNGPtgXY3hxrhoJWWyJdwKf3AQxu1ZVE/i74073/dOI74zIecjIB/tiDC/OVSMhiy3xTuCTc27RqmoCf3fcmb5/OvH9NHIeMvLBvhjDi3PVSMhiS7wT+OQmiNm1qprA3x13lu+fSXw/i5yHjHywL8bw4lw1ErLYEu8EPrkJYnatqibwd8ed7ftnEd85kfOQkQ/2xRhenKtGQhZb4p3AJzdBzK5V1QT+7rhzff9s4vt55Dxk5IN9MYYX56qRkMWWeCfwyU0Qs2tVNYG/O+483z+X+H4ROQ8Z+WBfjOHFuWokZLEl3gl8chPE7FpVTeDvjjvf988jvl9GzkNGPtgXY3hxrhoJWWyJdwKf3AQxu1ZVE/i74y7w/fOJ71eR85CRD/bFGF6cq0ZCFlvincAnN0HMrlXVBP7uuAt9/wLi+3XkPGTkg30xhhfnqpGQxZZ4J/DJTRCza1U1gb877iLfv5D4fhM5Dxn5YF+M4cW5aiRksSXeCXxyE8TsWlVN4O+Ou9j3LyK+SyLnISMf7IsxvDhXjYQstsQ7gU9ugphdq6oJ/N1xl/r+xcT328h5yMgH+2IML85VIyGLLfFO4JObIGbXqmoCf3fcZb5/KfH9LnIeMvLBvhjDi3PVSMhiS7wT+OQmiNm1qprA3x13ue9fRny/j5yHjHywL8bw4lw1ErLYEu8EPrkJYnatqibMcmVcluLfhLiiByxXEstVcVmK/7b2avICF3wsrfN5cHVcjuKcvCqIH2PmU9Ylm9XQ3OW9zMKvXVekYyn+TYjQO4FPboKYXat6XeKaXOP7VxHfH+LyFTW5JmDBGF6cq0ZCFlvincAn59yiVdWEWa6LytJZ3MN5bQ9YriOW66OydL9v3UBe4IKPpXU+D26Iy1Gck9cH8WPMfMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMq6ZLMamruml1n4Xuhrk7F0Fv+fvqF3gphzE8TsWtV9zlyTG33/euK7KS5fUZMbAxaM4cW5aiRksSXeCXxyE8TsWlVNmOWWqCx5cR/8zT1guYVYbo3K0n0f/G3kBS74WFrn8+C2uBzFOXlrED/GzKesyqqsyqqsyqqsyqqsyqqsyqqsyqqsyqqsyqqsytpXWA3N3djLLJYYbk7Gkhe/w4TeCWLOTRCza1Xfs3NNbvf9W4nvj3H5iprcHrBgDC/OVSMhiy3xTuCTmyBm16pqwix3RmWZXfwOc0cPWO4klruisnT/DnM3eYELPpbW+Ty4Oy5HcU7eFcSPMfMpq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqq7Iqa3xWQ3O39zIL30tyRzKW2cV9RKF3gphzE8TsWtV9IlyTe3z/LuL7U1y+oib3BCwYw4tz1UjIYku8E/jkJojZtaqaMMt9UVk6ivuI7u0By33Ecn9Ulu77iB4gL3DBx9I6nwcPxOUozsn7g/gxZj5lVVZlVVZlVVZlVVZlXbJZDc3d08ss/Fnm3mQsHcXn2NA7Qcy5CWJ2repzCtfkQd+/n/j+HJevqMmDAQvG8OJcNRKy2BLvBD65CWJ2raomzPJwXJa5juWhHrA8TCyPxGUpPsc+Sl7ggo+ldT4PHo3LUZyTjwTxY8x8yqqsyqqsyqqsyhqf1dDcg73MwteGD6VjmWtLvBP45CaI2bWq6z6uyWO+/wjx/SUuX1GTxwIWjOHFuWokZLEl3gl8chPE7FpVTZjlibgsxeeCx3vA8gSxPBmXpfhc8BR5Pe4f4WNpnc+Dp+JyFOfkk0H8GDOfsiqrsiqrsiqrssZnNTT3WC+z8LXh4+lYis8FoXcCn9wEMbtWdd3HNXna958kvr/G5Stq8nTAgjG8OFeNhCy2xDuBT26CmF2rqgmzPBuXpdOxPNMDlmeJ5bm4LMXngufJC1zwsbTO58HzcTmKc/K5IH6MmU9Zl2xWQ3NP9zILv3Y9k46l05Z4J/DJTRCza1WvS1yTF3z/OeJ7MS5fUZMXAhaM4cW5aiRksSXeCXxyE8TsWlVN4O+Oe8n3XyC+v0XOQ0Y+2BdjeHGuGglZbIl3Ap/cBDG7VlUT+LvjXvb9l4jv75HzkJEP9sUYXpyrRkIWW+KdwCc3QcyuVdUE/u64V3z/ZeL7R+Q8ZOSDfTGGF+eqkZDFlngn8MlNELNrVTWBvzvuVd9/hfj+GTkPGflgX4zhxblqJGSxJd4JfHITxOxaVU3g7457zfdfJb5/Rc5DRj7YF2N4ca4aCVlsiXcCn9wEMbtWVRP4u+Ne9/3XiO/fkfOQkQ/2xRhenKtGQhZb4p3AJzdBzK5V1QT+7rg3fP914vtP5Dxk5IN9MYYX56qRkMWWeCfwyU0Qs2tVNWGWN+OytLs934qcR7fH28SPWMFuaf0tiu3tyBwZeWJfjJnvg7KO7GXWVPV/J+6exfnNOXWt6vx+h+L7n8gsg2WPttqiumL/MLcttXJYrON1Z5Do3ZK/Q78frfNrVUsWNa7ifMmyRdYZeYDF+bYm8IVPf3j7Mbxa6W8uHdT9OKTW/Z6C+VGUm/6RGZ1Pv+CEqzr/+lO+BsRlKb6XbiNzcMHH0noLcbQlqNuAbPH4MW4jFjQ8HxLkpKOqFgNKWMY2EcuYJmIZ3UQsw5qIZXATsZgmYhnQRCytTcQypIlYBjURS1sTsfRrIpaWdNcLPWZ5t4nyMrSJWGwTsQxsIpb+TcSS9TKLqb3/c4Gh9XdpDtfI/ejYlpL98L7WRp+R3hj2/n1Sx84+XTSG1yBiaEv8evZBWPo3EcvAJmKxTcQytIlY3m0ilpaseVj6NVFe2pqIZVATsQxpIpbWJmIZ0EQspolYBjcRy7AmYhndRCxjmohlbBOxtJSwDIzL0snX7GjBcLHr/4HEYuKyFL+nDYq8p9vDUkDvfd7wj5bWB1FsNkHNTbZ4Tt9joHllXbJZ4/t2Fv/GsunBc5xZBid4Pg4hc3ANploMKanFkAS1GBzUAmPmU1ZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVVZlVdYlmzW+7+zi/l72dS0YvucVsgyNm4Pi/t5hZA6uoVSLYSW1GJagFkODWmDMfMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMqqrMoanzWB71wT+LoWDN/zClmGx2Up7o9YiszBNZxqsVRJLZZKUIvhQS0wZj5lVVZlVVZlVVZljc8a3zcv7gdlX9eC4WLXO8wyIm4OiuudpckcXCOoFkuX1GLpBLUYEdQCY+ZTVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmXtK6zxfbv/vQH2dS0YLvb9MrMsEzcHxffLI8kcXMtQLUaW1GJkglosE9QCY+ZTVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVVVmVV1visCXw7TeDrWjB8zytkGRWXpbg/YjSZg2sU1WJ0SS1GJ6jFqKAWGDOfsi7ZrAl8cxP4ulb1fGSWMQmej2PJHFxjqBZjS2oxNkEtxgS1wJj5+gqrobmW2qI5rLfS3Dg/14/mxvu5/jS3LMWEuQl+ro3mJvq5gTQ3CbmiuTr2I+bJ6NPcFN8fTHNTfX8ozS3n+8Npbprvj6C56cH7r5ubEbwGuLmZQS3d3PLUx+MK+DuaW5HOCcythDhobmU/N4TmZiE2mlvFzw2jufYSPtR6DM2h1nxuoNbjaA61Hk9zqPWyNIdaT6A51HoizSFHk2gOOarTHHI0meaQoyk0hxxNpTnkaDmaQ46m0dxwPzed5pbyczNoboSfm0lzS/s5rv0yfm4Fmhvp51akuVF+biWaG+3nVubnqp+bRXNj/dwqNDfOz7XT887VqO7nu7D+4VrxHjG5tnireo+o+0fHMikuS3F/7QS/12TyWTauT/G6OiGID2N4WWKYlJDFlnjH98nbOeYWX8fRgW/xfuD7E4hlatyYc8cyjvavky+8Wulv3vJPfvdadsawRcdFPv+K50K9tnirei6kOy/yxZ4LH4SFz53xUVna292e4yLv6faYSvyIFeyW1vlciXwuFq8F42uL5zQ8F5VVWZVVWZVVWZVVWZVVWZVVWZVVWZVVWZVVWZVVWfsSK3/XX+9lFksM6X53yNttiXeK78v5Nz3s7X67OIZ+u5gQOTaXZ/49ok4M8Gqlv7lq2CKu431/EK3Xa8lY5ybIefHbDX4DQav6vWQ8xRf3t4283f2m3Ua5HBfUAZwtxLBcVIbu31emUbzwhI+rNZ4D+DtDff79dXpctuI1gdm6aAwv/v11akIWW+LNvzO6PNX9/BTK3aSSPMX9DbDjQ/0GGPv3uiyoQxd5sG/k87iDfTMveGC+lfoX4aYQ+jvX6v4RzK6G40v+jvsTgmMsrY9PHPM44uiiMbzcOXoOxTq+hHs0cWOd3yMivwYX3PwaXCcGePG9LVOIJcV1x/+VQ77umBLkLD5LR3HdEXrz/UHImavpmcSR8hohvAdkAnGBB38bXsPV6W/G0nGIMeFzIw9fh+q19z83+PXgJrrOee3/uc6JfG9PzvfchKz8mpnymtvd68cc/JqJv7nD52WI55kWOQ/FPZu1xVvV+9g0yk3k9/viumgGeYGLrzuwPpI4ZsTlKGo0PYgfY+b7oKwTm4B1eglr2fvt9GSs3fdNMYdrVefaDGJZPipL9zXTCrR/F3mw74pxfTvYF9dM8MB8K/VfpOuIFRd133uNBLOr4cySv+P+9OAYS+szE8e8PHF00Rhe7j3gcYp1Zgn3WOLGOl+7oG51imVmglhmBLHMCJj5O5PpyVi6vzMJvfm9NP51Snf8k2qLWr32/u8y+DuWScTF37H0j8zF99OjVb22wN/dM4/73BcsnDd/zm67bDV/j4W7ZLRHv2C/FtqnhdZag79rq72fIVrAI8msxZv384EN8OYuONzwb32g7kLC3bPrauFuyHc34Lsb7t0N9u6G+pHE+qx/dDfQu4tRd4O8K6x743BPPHeh5Iru3uBcoeu17g/d7sLdXcy4Nxp3weCeBO5EdSepe+K7Fzf3xF9JtLJolmgVlxNRhygXzRZ1ij4iWlX0UdFqoo+JVhd9XLSG6BOiNUWf9Ln9lKghWkv0adHaos+I1hGtK1pPtL5oA9FnRRuKNhJtLNpEtKnoc6LNRJuLthBtKdpK9HnR1qJtRNuKthNtL/qCaAfRjqI5op1Ec0U7i3YR7SraTbS7aA/RF0V7ivYS7S3aRzRP9CXRvqL5ogWihaL9RF8W7S/6iugA0YGig0RfFR0s+proENGhosNEXxcdLvqG6AjRN0VHir4lOkr0bdHRomNEx4q+IzpOdLzou6ITRN8TnSj6vugk0Q9EJ4t+KDpF9CPRqaIfi04T/UR0uuiMWvcHpZ+KzhL9THS26BzRuaKfi84T/UJ0vuiXogtEvxJdKPq16CLRb0QXiy4RXSr6regy0e9El4t+L7pCdKXoKtHVomtEfxBdK7pOdL3oBtGNoptEN4tuEd0quk10u+iPojtEd4ruEt0tukf0J9G9ovtE94seED0o+rPoIdHDokdEj4oeE/1F9LjoCdGToqdET4v+Knqm1v1cek70vOgF0Yuil0R/E70s+rvoFdE/RK+K/il6TfQv0euif4veEP1H9KboLdHbtUUvMPxCc4n/L3zW8OPNul/Y6gv2mrew3l7fR/53zl57zdt/l51n1XltQX3v/RYsrC9YOGf+wvqu8+ftXe+Y9b+AxFSHqcsCAA==", "verificationKey": "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" } ] diff --git a/yarn-project/circuits.js/src/structs/side_effects.ts b/yarn-project/circuits.js/src/structs/side_effects.ts index ffa34422e1c7..149164776af2 100644 --- a/yarn-project/circuits.js/src/structs/side_effects.ts +++ b/yarn-project/circuits.js/src/structs/side_effects.ts @@ -3,11 +3,26 @@ import { BufferReader } from '@aztec/foundation/serialize'; import { serializeToBuffer } from '../utils/serialize.js'; import { Fr } from './index.js'; + +/** + * Essential members and functions of all SideEffect variants + */ +interface SideEffectType { + /** The actual value associated with the SideEffect */ + value: Fr, + /** Convert to a buffer */ + toBuffer(): Buffer; + /** Convert to a field array */ + toFieldArray(): Fr[]; + /** Are all of the fields of the SideEffect zero? */ + isEmpty(): boolean; +} + /** * Side-effect object consisting of a value and a counter. * cpp/src/aztec3/circuits/abis/side_effects.hpp. */ -export class SideEffect { +export class SideEffect implements SideEffectType { constructor( /** * The value of the side-effect object. @@ -27,6 +42,14 @@ export class SideEffect { return serializeToBuffer(this.value, this.sideEffectCounter); } + /** + * Convert to an array of fields. + * @returns The array of fields. + */ + toFieldArray(): Fr[] { + return [this.value, this.sideEffectCounter]; + } + /** * Returns whether this instance of side-effect is empty. * @returns True if the value and counter both are zero. @@ -52,13 +75,14 @@ export class SideEffect { const reader = BufferReader.asReader(buffer); return new SideEffect(reader.readFr(), reader.readFr()); } + } /** * Side-effect object consisting of a value, a start counter and an end counter. * cpp/src/aztec3/circuits/abis/side_effects.hpp. */ -export class SideEffectWithRange { +export class SideEffectWithRange implements SideEffectType { constructor( /** * The value of the side-effect object. @@ -82,6 +106,14 @@ export class SideEffectWithRange { return serializeToBuffer(this.value, this.startSideEffectCounter, this.endSideEffectCounter); } + /** + * Convert to an array of fields. + * @returns The array of fields. + */ + toFieldArray(): Fr[] { + return [this.value, this.startSideEffectCounter, this.endSideEffectCounter]; + } + /** * Returns whether this instance of side-effect is empty. * @returns True if the value and both counters are zero. @@ -113,7 +145,7 @@ export class SideEffectWithRange { * Side-effect object consisting of a value, a start counter and an end counter. * cpp/src/aztec3/circuits/abis/side_effects.hpp. */ -export class SideEffectLinkedToNoteHash { +export class SideEffectLinkedToNoteHash implements SideEffectType { constructor( /** * The value of the side-effect object. @@ -137,6 +169,14 @@ export class SideEffectLinkedToNoteHash { return serializeToBuffer(this.value, this.noteHash, this.sideEffectCounter); } + /** + * Convert to an array of fields. + * @returns The array of fields. + */ + toFieldArray(): Fr[] { + return [this.value, this.noteHash, this.sideEffectCounter]; + } + /** * Returns whether this instance of side-effect is empty. * @returns True if the value, note hash and counter are all zero. @@ -162,4 +202,23 @@ export class SideEffectLinkedToNoteHash { const reader = BufferReader.asReader(buffer); return new SideEffectLinkedToNoteHash(reader.readFr(), reader.readFr(), reader.readFr()); } + } + +/** + * Convert an array of side effects to an array only non-empty side effects. + * @param sideEffects - array to be converted + * @returns the array of the non-empty side effects + */ +export function nonEmptySideEffects(sideEffects: SideEffectType[]): SideEffectType[]{ + return sideEffects.filter!(sideEffect => !sideEffect.isEmpty()); +} + +/** + * Convert an array of side effects to an array of their values. + * @param sideEffects - array to be converted + * @returns the array of field values (excluding SideEffect metadata like counter) + */ +export function sideEffectArrayToValueArray(sideEffects: SideEffectType[]): Fr[] { + return sideEffects.map(sideEffect => sideEffect.value); +} \ No newline at end of file diff --git a/yarn-project/types/src/tx/tx.ts b/yarn-project/types/src/tx/tx.ts index 4486aa8b8aba..51c414e564b3 100644 --- a/yarn-project/types/src/tx/tx.ts +++ b/yarn-project/types/src/tx/tx.ts @@ -56,7 +56,7 @@ export class Tx { } const kernelPublicCallStackSize = - data?.end.publicCallStack && arrayNonEmptyLength(data.end.publicCallStack, item => item.isZero()); + data?.end.publicCallStack && arrayNonEmptyLength(data.end.publicCallStack, item => item.isEmpty()); if (kernelPublicCallStackSize && kernelPublicCallStackSize > (enqueuedPublicFunctionCalls?.length ?? 0)) { throw new Error( `Missing preimages for enqueued public function calls in kernel circuit public inputs (expected From beafecfb588e98a606ecb064bc8a7cd3f740aa77 Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Wed, 11 Oct 2023 20:33:14 +0000 Subject: [PATCH 4/7] C++ fixes for hashing --- .../cpp/src/aztec3/circuits/abis/packers.hpp | 8 ++ .../abis/private_circuit_public_inputs.hpp | 23 ++---- .../abis/public_circuit_public_inputs.hpp | 8 +- .../src/aztec3/circuits/abis/side_effects.hpp | 22 +++-- .../aztec3/circuits/kernel/private/utils.cpp | 2 +- circuits/cpp/src/aztec3/constants.hpp | 82 +++++++++---------- 6 files changed, 75 insertions(+), 70 deletions(-) diff --git a/circuits/cpp/src/aztec3/circuits/abis/packers.hpp b/circuits/cpp/src/aztec3/circuits/abis/packers.hpp index fb001b0f049a..0acc774c2045 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/packers.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/packers.hpp @@ -129,6 +129,10 @@ struct GeneratorIndexPacker { int SIGNED_TX_REQUEST = GeneratorIndex::SIGNED_TX_REQUEST; int GLOBAL_VARIABLES = GeneratorIndex::GLOBAL_VARIABLES; int PARTIAL_ADDRESS = GeneratorIndex::PARTIAL_ADDRESS; + int BLOCK_HASH = GeneratorIndex::BLOCK_HASH; + int SIDE_EFFECT = GeneratorIndex::SIDE_EFFECT; + int SIDE_EFFECT_LINKED_TO_NOTE_HASH = GeneratorIndex::SIDE_EFFECT_LINKED_TO_NOTE_HASH; + int SIDE_EFFECT_WITH_RANGE = GeneratorIndex::SIDE_EFFECT_WITH_RANGE; int TX_REQUEST = GeneratorIndex::TX_REQUEST; int SIGNATURE_PAYLOAD = GeneratorIndex::SIGNATURE_PAYLOAD; int VK = GeneratorIndex::VK; @@ -166,6 +170,10 @@ struct GeneratorIndexPacker { SIGNED_TX_REQUEST, GLOBAL_VARIABLES, PARTIAL_ADDRESS, + BLOCK_HASH, + SIDE_EFFECT, + SIDE_EFFECT_LINKED_TO_NOTE_HASH, + SIDE_EFFECT_WITH_RANGE, TX_REQUEST, SIGNATURE_PAYLOAD, VK, diff --git a/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp b/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp index 3da596f7f819..6484ec5aaa7a 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/private_circuit_public_inputs.hpp @@ -180,7 +180,7 @@ template class PrivateCircuitPublicInputs { fr hash() const { - // auto to_hashes = [](const T& e) { return e.hash(); }; + auto to_hashes = [](const T& e) { return e.hash(); }; std::vector inputs; @@ -189,16 +189,16 @@ template class PrivateCircuitPublicInputs { inputs.push_back(args_hash); spread_arr_into_vec(return_values, inputs); - spread_arr_into_vec(read_requests, inputs); + spread_arr_into_vec(map(read_requests, to_hashes), inputs); - spread_arr_into_vec(new_commitments, inputs); - spread_arr_into_vec(new_nullifiers, inputs); + spread_arr_into_vec(map(new_commitments, to_hashes), inputs); + spread_arr_into_vec(map(new_nullifiers, to_hashes), inputs); // TODO(dbanks12): remove me! spread_arr_into_vec(nullified_commitments, inputs); - spread_arr_into_vec(private_call_stack, inputs); - spread_arr_into_vec(public_call_stack, inputs); - spread_arr_into_vec(new_l2_to_l1_msgs, inputs); + spread_arr_into_vec(map(private_call_stack, to_hashes), inputs); + spread_arr_into_vec(map(public_call_stack, to_hashes), inputs); + spread_arr_into_vec(map(new_l2_to_l1_msgs, to_hashes), inputs); spread_arr_into_vec(encrypted_logs_hash, inputs); spread_arr_into_vec(unencrypted_logs_hash, inputs); @@ -224,15 +224,6 @@ template class PrivateCircuitPublicInputs { const auto arr_size = sizeof(arr) / sizeof(fr); vec.insert(vec.end(), arr.data(), arr.data() + arr_size); } - - template - void spread_arr_into_vec(std::array const& arr, std::vector& vec) const - { - const auto arr_size = sizeof(arr) / sizeof(fr); - for (size_t i = 0; i < arr_size; i++) { - vec.insert(vec.end(), arr[i].value); - } - } }; // It's been extremely useful for all members here to be std::optional. It allows test app circuits to be very diff --git a/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp b/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp index 0328634a0bfc..d70ce72c2b73 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/public_circuit_public_inputs.hpp @@ -114,10 +114,10 @@ template struct PublicCircuitPublicInputs { spread_arr_into_vec(map(contract_storage_update_requests, to_hashes), inputs); spread_arr_into_vec(map(contract_storage_reads, to_hashes), inputs); - spread_arr_into_vec(public_call_stack, inputs); - spread_arr_into_vec(new_commitments, inputs); - spread_arr_into_vec(new_nullifiers, inputs); - spread_arr_into_vec(new_l2_to_l1_msgs, inputs); + spread_arr_into_vec(map(public_call_stack, to_hashes), inputs); + spread_arr_into_vec(map(new_commitments, to_hashes), inputs); + spread_arr_into_vec(map(new_nullifiers, to_hashes), inputs); + spread_arr_into_vec(map(new_l2_to_l1_msgs, to_hashes), inputs); spread_arr_into_vec(unencrypted_logs_hash, inputs); inputs.push_back(unencrypted_log_preimages_length); diff --git a/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp b/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp index 1c4fbe5c8616..74c20fc4be35 100644 --- a/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp +++ b/circuits/cpp/src/aztec3/circuits/abis/side_effects.hpp @@ -1,5 +1,6 @@ #pragma once +#include "aztec3/constants.hpp" #include "aztec3/utils/types/circuit_types.hpp" #include "aztec3/utils/types/convert.hpp" #include "aztec3/utils/types/native_types.hpp" @@ -9,13 +10,6 @@ namespace aztec3::circuits::abis { using aztec3::utils::types::CircuitTypes; using aztec3::utils::types::NativeTypes; -// template -// void spread_struct_arr_into_vec(std::array const& arr, std::vector& vec) -//{ -// const auto arr_size = sizeof(arr) / sizeof(SE); -// vec.insert(vec.end(), arr.data, arr.data() + arr_size); -// } - template struct SideEffect { using fr = typename NCT::fr; using boolean = typename NCT::boolean; @@ -68,6 +62,8 @@ template struct SideEffect { }; } + fr hash() const { return NCT::hash({ value, side_effect_counter }, GeneratorIndex::SIDE_EFFECT); } + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? template void assert_is_zero() { @@ -145,6 +141,11 @@ template struct SideEffectLinkedToNoteHash { }; } + fr hash() const + { + return NCT::hash({ value, note_hash, side_effect_counter }, GeneratorIndex::SIDE_EFFECT_LINKED_TO_NOTE_HASH); + } + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? template void assert_is_zero() { @@ -155,6 +156,7 @@ template struct SideEffectLinkedToNoteHash { side_effect_counter.assert_is_zero(); } + boolean is_empty() const { return ((value.is_zero()) && (note_hash.is_zero()) && (side_effect_counter.is_zero())); } void set_public() @@ -224,6 +226,12 @@ template struct SideEffectWithRange { }; } + fr hash() const + { + return NCT::hash({ value, start_side_effect_counter, end_side_effect_counter }, + GeneratorIndex::SIDE_EFFECT_WITH_RANGE); + } + // TODO(dbanks12): should `assert_is_zero` just return whether value is zero? template void assert_is_zero() { diff --git a/circuits/cpp/src/aztec3/circuits/kernel/private/utils.cpp b/circuits/cpp/src/aztec3/circuits/kernel/private/utils.cpp index 3c4e8c3501b8..29c6701b8ec2 100644 --- a/circuits/cpp/src/aztec3/circuits/kernel/private/utils.cpp +++ b/circuits/cpp/src/aztec3/circuits/kernel/private/utils.cpp @@ -90,7 +90,7 @@ std::shared_ptr get_verification_key_from_file() std::shared_ptr fake_vk() { std::map commitments; - commitments["FAKE"] = *new NT::bn254_point(NT::fq(0), NT::fq(0)); + commitments["FAKE"] = NT::bn254_point(NT::fq(0), NT::fq(0)); NT::VKData vk_data = { .circuit_type = static_cast(CircuitType::ULTRA), .circuit_size = 2048, .num_public_inputs = 116, diff --git a/circuits/cpp/src/aztec3/constants.hpp b/circuits/cpp/src/aztec3/constants.hpp index 37f9a04d5b80..f42700a7a85b 100644 --- a/circuits/cpp/src/aztec3/constants.hpp +++ b/circuits/cpp/src/aztec3/constants.hpp @@ -141,34 +141,37 @@ enum GeneratorIndex { /** * Indices with size ≤ 8 */ - COMMITMENT = 1, // Size = 7 (unused) - COMMITMENT_NONCE, // Size = 2 - UNIQUE_COMMITMENT, // Size = 2 - SILOED_COMMITMENT, // Size = 2 - NULLIFIER, // Size = 4 (unused) - INITIALISATION_NULLIFIER, // Size = 2 (unused) - OUTER_NULLIFIER, // Size = 2 - PUBLIC_DATA_READ, // Size = 2 - PUBLIC_DATA_UPDATE_REQUEST, // Size = 3 - FUNCTION_DATA, // Size = 4 - FUNCTION_LEAF, // Size = 5 - CONTRACT_DEPLOYMENT_DATA, // Size = 4 - CONSTRUCTOR, // Size = 3 - CONSTRUCTOR_ARGS, // Size = 8 - CONTRACT_ADDRESS, // Size = 4 - CONTRACT_LEAF, // Size = 3 - CALL_CONTEXT, // Size = 6 - CALL_STACK_ITEM, // Size = 3 - CALL_STACK_ITEM_2, // Size = ? (unused), // TODO see function where it's used for explanation - L1_TO_L2_MESSAGE_SECRET, // Size = 1 - L2_TO_L1_MSG, // Size = 2 (unused) - TX_CONTEXT, // Size = 4 - PUBLIC_LEAF_INDEX, // Size = 2 (unused) - PUBLIC_DATA_LEAF, // Size = ? (unused) // TODO what's the expected size? Assuming ≤ 8 - SIGNED_TX_REQUEST, // Size = 7 - GLOBAL_VARIABLES, // Size = 4 - PARTIAL_ADDRESS, // Size = 7 - BLOCK_HASH, // Size = 6 + COMMITMENT = 1, // Size = 7 (unused) + COMMITMENT_NONCE, // Size = 2 + UNIQUE_COMMITMENT, // Size = 2 + SILOED_COMMITMENT, // Size = 2 + NULLIFIER, // Size = 4 (unused) + INITIALISATION_NULLIFIER, // Size = 2 (unused) + OUTER_NULLIFIER, // Size = 2 + PUBLIC_DATA_READ, // Size = 2 + PUBLIC_DATA_UPDATE_REQUEST, // Size = 3 + FUNCTION_DATA, // Size = 4 + FUNCTION_LEAF, // Size = 5 + CONTRACT_DEPLOYMENT_DATA, // Size = 4 + CONSTRUCTOR, // Size = 3 + CONSTRUCTOR_ARGS, // Size = 8 + CONTRACT_ADDRESS, // Size = 4 + CONTRACT_LEAF, // Size = 3 + CALL_CONTEXT, // Size = 6 + CALL_STACK_ITEM, // Size = 3 + CALL_STACK_ITEM_2, // Size = ? (unused), // TODO see function where it's used for explanation + L1_TO_L2_MESSAGE_SECRET, // Size = 1 + L2_TO_L1_MSG, // Size = 2 (unused) + TX_CONTEXT, // Size = 4 + PUBLIC_LEAF_INDEX, // Size = 2 (unused) + PUBLIC_DATA_LEAF, // Size = ? (unused) // TODO what's the expected size? Assuming ≤ 8 + SIGNED_TX_REQUEST, // Size = 7 + GLOBAL_VARIABLES, // Size = 4 + PARTIAL_ADDRESS, // Size = 7 + BLOCK_HASH, // Size = 6 + SIDE_EFFECT, // Size = 2 + SIDE_EFFECT_LINKED_TO_NOTE_HASH, // Size = 3 + SIDE_EFFECT_WITH_RANGE, // Size = 3 /** * Indices with size ≤ 16 */ @@ -245,20 +248,18 @@ constexpr size_t PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH = MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + MAX_NEW_NULLIFIERS_PER_CALL + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + - MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + + MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + NUM_FIELDS_PER_SHA256 + + NUM_FIELDS_PER_SHA256 + // sha256s for log hashes 2 // + 2 for logs preimage lengths + HISTORIC_BLOCK_DATA_LENGTH + CONTRACT_DEPLOYMENT_DATA_LENGTH + 2; // + 2 for chain_id and version constexpr size_t PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 1 + 1 // call_context_hash + args_hash - + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL * SIDE_EFFECT_LENGTH + - MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + - MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + MAX_NEW_NULLIFIERS_PER_CALL + - MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + - MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + // *3 for start/end sideeffect counters - MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + // *2 for sideeffect counter - NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + 2 // + 2 for logs preimage lengths - + HISTORIC_BLOCK_DATA_LENGTH + 3; // + 3 for contract_deployment_data.hash(), chain_id, version + + RETURN_VALUES_LENGTH + MAX_READ_REQUESTS_PER_CALL + MAX_NEW_COMMITMENTS_PER_CALL + MAX_NEW_NULLIFIERS_PER_CALL + + MAX_NEW_NULLIFIERS_PER_CALL + MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + + MAX_NEW_L2_TO_L1_MSGS_PER_CALL + NUM_FIELDS_PER_SHA256 + NUM_FIELDS_PER_SHA256 + + 2 + // + 2 for logs preimage lengths + HISTORIC_BLOCK_DATA_LENGTH + 3; // + 3 for contract_deployment_data.hash(), chain_id, version constexpr size_t CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH = 4; constexpr size_t CONTRACT_STORAGE_READ_LENGTH = 3; @@ -277,11 +278,8 @@ constexpr size_t PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH = constexpr size_t PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH = 2 + RETURN_VALUES_LENGTH + // + 1 for args_hash + 1 call_context.hash - MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL + MAX_PUBLIC_DATA_READS_PER_CALL + - MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL * SIDE_EFFECT_WITH_RANGE_LENGTH + - MAX_NEW_COMMITMENTS_PER_CALL * SIDE_EFFECT_LENGTH + - MAX_NEW_NULLIFIERS_PER_CALL * SIDE_EFFECT_LINKED_TO_NOTEHASH_LENGTH + - MAX_NEW_L2_TO_L1_MSGS_PER_CALL * SIDE_EFFECT_LENGTH + + MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL + MAX_PUBLIC_DATA_READS_PER_CALL + MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL + + MAX_NEW_COMMITMENTS_PER_CALL + MAX_NEW_NULLIFIERS_PER_CALL + MAX_NEW_L2_TO_L1_MSGS_PER_CALL + NUM_FIELDS_PER_SHA256 + // unencrypted_logs_hash (being represented by NUM_FIELDS_PER_SHA256) HISTORIC_BLOCK_DATA_LENGTH + 2; // unencrypted_log_preimages_length + prover_address From 7f6643fa60afeb07c5017254690784283aa625c5 Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Wed, 11 Oct 2023 20:38:10 +0000 Subject: [PATCH 5/7] fixes in TS --- yarn-project/acir-simulator/src/acvm/serialize.ts | 1 + .../acir-simulator/src/client/client_execution_context.ts | 3 ++- .../acir-simulator/src/client/private_execution.test.ts | 2 +- yarn-project/acir-simulator/src/public/executor.ts | 6 +++--- .../acir-simulator/src/public/public_execution_context.ts | 5 +++-- yarn-project/aztec-nr/aztec/src/abi.nr | 4 +++- 6 files changed, 13 insertions(+), 8 deletions(-) diff --git a/yarn-project/acir-simulator/src/acvm/serialize.ts b/yarn-project/acir-simulator/src/acvm/serialize.ts index 0153dca4bcbe..53d557fe0c3e 100644 --- a/yarn-project/acir-simulator/src/acvm/serialize.ts +++ b/yarn-project/acir-simulator/src/acvm/serialize.ts @@ -76,6 +76,7 @@ export function toACVMCallContext(callContext: CallContext): ACVMField[] { toACVMField(callContext.isDelegateCall), toACVMField(callContext.isStaticCall), toACVMField(callContext.isContractDeployment), + toACVMField(callContext.startSideEffectCounter), ]; } diff --git a/yarn-project/acir-simulator/src/client/client_execution_context.ts b/yarn-project/acir-simulator/src/client/client_execution_context.ts index baebea48d1c1..24b67ca4c4fb 100644 --- a/yarn-project/acir-simulator/src/client/client_execution_context.ts +++ b/yarn-project/acir-simulator/src/client/client_execution_context.ts @@ -103,7 +103,8 @@ export class ClientExecutionContext extends ViewDataOracle { this.txContext.chainId, this.txContext.version, - this.sideEffectCounter, // TODO(dbanks12): correct name? start? + this.callContext.startSideEffectCounter, // TODO(dbanks12): is this right? + //this.sideEffectCounter.count, ...this.packedArgsCache.unpack(this.argsHash), ]; diff --git a/yarn-project/acir-simulator/src/client/private_execution.test.ts b/yarn-project/acir-simulator/src/client/private_execution.test.ts index c358f78c75f2..f250fdf8abf1 100644 --- a/yarn-project/acir-simulator/src/client/private_execution.test.ts +++ b/yarn-project/acir-simulator/src/client/private_execution.test.ts @@ -631,7 +631,7 @@ describe('Private Execution test suite', () => { // check that Aztec.nr calculated the call stack item hash like cpp does const wasm = await CircuitsWasm.get(); const expectedCallStackItemHash = computeCallStackItemHash(wasm, result.nestedExecutions[0].callStackItem); - expect(result.callStackItem.publicInputs.privateCallStack[0]).toEqual(expectedCallStackItemHash); + expect(result.callStackItem.publicInputs.privateCallStack[0].value).toEqual(expectedCallStackItemHash); }); }); diff --git a/yarn-project/acir-simulator/src/public/executor.ts b/yarn-project/acir-simulator/src/public/executor.ts index ca626a1812bb..557c5b0b3d2c 100644 --- a/yarn-project/acir-simulator/src/public/executor.ts +++ b/yarn-project/acir-simulator/src/public/executor.ts @@ -46,9 +46,9 @@ export async function executePublicFunction( newNullifiers: newNullifiersPadded, } = extractPublicCircuitPublicInputs(partialWitness, acir); - const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isZero()); - const newCommitments = newCommitmentsPadded.filter(v => !v.isZero()); - const newNullifiers = newNullifiersPadded.filter(v => !v.isZero()); + const newL2ToL1Messages = newL2ToL1Msgs.filter(v => !v.isEmpty()); + const newCommitments = newCommitmentsPadded.filter(v => !v.isEmpty()); + const newNullifiers = newNullifiersPadded.filter(v => !v.isEmpty()); const { contractStorageReads, contractStorageUpdateRequests } = context.getStorageActionData(); log( diff --git a/yarn-project/acir-simulator/src/public/public_execution_context.ts b/yarn-project/acir-simulator/src/public/public_execution_context.ts index d9a5b0453bb9..4e2343c162a6 100644 --- a/yarn-project/acir-simulator/src/public/public_execution_context.ts +++ b/yarn-project/acir-simulator/src/public/public_execution_context.ts @@ -73,7 +73,8 @@ export class PublicExecutionContext extends TypedOracle { this.globalVariables.blockNumber, this.globalVariables.timestamp, - this.sideEffectCounter, // TODO(dbanks12): correct name? start? + callContext.startSideEffectCounter, // TODO(dbanks12): is this right? + //this.sideEffectCounter.count, ...args, ]; @@ -228,7 +229,7 @@ export class PublicExecutionContext extends TypedOracle { isContractDeployment: false, isDelegateCall: false, isStaticCall: false, - Fr.ZERO, // TODO(dbanks12): add arg for this? + startSideEffectCounter: Fr.ZERO, // TODO(dbanks12): add arg for this? }); const nestedExecution: PublicExecution = { diff --git a/yarn-project/aztec-nr/aztec/src/abi.nr b/yarn-project/aztec-nr/aztec/src/abi.nr index d4fd85bb325c..cb735e96df33 100644 --- a/yarn-project/aztec-nr/aztec/src/abi.nr +++ b/yarn-project/aztec-nr/aztec/src/abi.nr @@ -191,6 +191,7 @@ struct PrivateContextInputs { contract_deployment_data: ContractDeploymentData, private_global_variables: PrivateGlobalVariables, + // TODO(dbanks12): needed? start_side_effect_counter: Field, } // docs:end:private-context-inputs @@ -203,6 +204,7 @@ struct PublicContextInputs { public_global_variables: PublicGlobalVariables, + // TODO(dbanks12): needed? start_side_effect_counter: Field, } // docs:end:public-context-inputs @@ -292,7 +294,7 @@ struct PrivateCircuitPublicInputs { call_context: CallContext, args_hash: Field, return_values: [Field; RETURN_VALUES_LENGTH], - read_requests: [SideEffect; crate::abi::MAX_READ_REQUESTS_PER_CALL], + read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL], new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL], new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL], nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL], From 342578c54693565c466a2ba2fe591f325f625667 Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Fri, 13 Oct 2023 18:42:10 +0000 Subject: [PATCH 6/7] boxes autoupdate --- .../blank-react/src/artifacts/Blank.json | 16 ++-- .../boxes/blank-react/src/artifacts/Blank.ts | 39 +++++----- .../boxes/blank/src/artifacts/Blank.json | 16 ++-- .../boxes/blank/src/artifacts/Blank.ts | 39 +++++----- .../src/artifacts/PrivateToken.json | 78 +++++++++---------- .../src/artifacts/PrivateToken.ts | 60 ++++++-------- 6 files changed, 120 insertions(+), 128 deletions(-) diff --git a/yarn-project/boxes/blank-react/src/artifacts/Blank.json b/yarn-project/boxes/blank-react/src/artifacts/Blank.json index c0c7b983be1e..2c4c23e03a20 100644 --- a/yarn-project/boxes/blank-react/src/artifacts/Blank.json +++ b/yarn-project/boxes/blank-react/src/artifacts/Blank.json @@ -7,7 +7,7 @@ "isInternal": false, "parameters": [], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -24,7 +24,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "H4sIAAAAAAAA/9XdZXBV1xqH8UNCkLq3uLvlREhS3N3dIRBcKtCWuru7u7vg7u7u7i51ofd9pytzz+XyjX8/PGfmnRWmnfD8QmTnnL3XPp0jEtlg4w9f4mwSwtvZf8511p9zh7djH9l/rh3W5MSqKSlZaUlZ0eRon8SkjMz01MSU1Myq6dH0aGp6ar+k9OTkrPSU9LSMzIy0xIxoSnJWtH9qRnL/xH8e+WPeV+J5Pv7NzgKQzoKQzkKQzsKQziKQzqKQzmKQzuKQzhKQzpKQzlKQztKQzjKQzrKQznKQzvKQzgqQzoqQzkqQzsqQziqQzkRIZxTSmQTpTIZ0pkA6UyGdVSGdaZDOdGGnt/lzjkXD+8tnc8Ymf1gLhLVgWAuFtXBYi4S1aFiLhbV4WEuEtWRYS4W1dFjLhLVsWMuFtXxYK4S1YlgrhbVyWKuENTGs0bAmhTU5rClhTQ1r1bCmhTU95u/JsLk+8r8P9b9htQjjc606pLMGpLMmpLMWpLM2pLMOpLMupLMepLM+pLMBpLMhpLMRpLMxpLNJRH/Me1l4f36858d+1cJaPaw1wlozrLXCWjusdcJaN6z1wlo/rA3C2jCsjcLaOKxNIv895mxq08wmPvL/r/ef6+OZeH6PaL6I9uOZ3Rgf3m5u08KmZYzh4rDmjfxzbkPsI1fM27VFXdnnUijfZ0JMa96Y5mzPJeG/59T+vcl5Yz62kZiPd+QcH7dIzN+fx+ai8PaArJGtR2UOHdS3Wdboc/2bxZ/j/cbFWBPO+v9i/x2z/9u5zleRfdJmf+HGfpL5F1CLsLYM66U2rWxan9URd1bP+X5TEn4RRVtFGN+I20A620I620E620M6O0A6O0I6O0E6O0M6u0A6u0I6u0E6u0M6e0A6e0I6e0E6e0M6+0A6MyGdfSGd/SCdWZDO/pDOAZDOgZDOQZDOwZDOIZDOoZDOYZDO4ZDOEZDOGyCdN0I6b4J03gzpHAnpHAXpvAXSeSuk8zZI52hI5+2QzjsgnXdCOu+CdN4N6bwH0nkvpPM+SOf9kM4HIJ0PQjofgnQ+DOl8BNL5KKTzMUjn45DOJyCdT0I6n4J0Pg3pfAbS+Syk8zlI5/OQzhcgnS9COl+CdL4M6XwF0vkqpPM1SOfrkM43IJ1vQjrfgnS+Del8B9L5LqTzPUjn+5DODyCdH0I6P4J0fgzp/ATS+Smk8zNI5+eQzi8gnV9COr+CdH4N6fwG0vktpPM7SOf3kM4fIJ1jIJ1jIZ3jIJ3jIZ0TIJ0TIZ2TIJ2TIZ1TIJ1TIZ3TIJ3TIZ0zIJ0zIZ2zIJ2zIZ1zIJ1zIZ3zIJ3zIZ0LIJ0LIZ2LIJ2LIZ1LIJ1LIZ3LIJ3LIZ0rIJ0rIZ2rIJ2rIZ1rIJ1rIZ3rIJ3rIZ0bIJ0bIZ2bIJ2bIZ1bIJ1bIZ3bIJ3bIZ07IJ07IZ27IJ27IZ17IJ17IZ37IJ37IZ0HIJ0HIZ2HIJ2HIZ1HIJ1HIZ3HIJ3HIZ0nIJ0nIZ2nIJ2nIZ0/Qjp/gnT+DOn8BdL5K6TzN0jn75DOPyCdf0I6/4J0noF0/g3p9HdI6MwB6YyDdMZDOnNCOhMgnbkgnbkhnXkgnXkhnRdAOi+EdF4E6bwY0nkJpPNSSOdlkM7LIZ1XQDqvhHRe9S91xp3VmXh+j2gOoflqiDlOaL4GYo4Xmq+FmHMKzddBzAlCcz6IOZfQnB9izi00F4CY8wjNBSHmpkJzIYi5udBcGGJuITQXgZjbCM1FIea2QnMxiLmd0FwcYm4vNJeAmDsIzSUh5o5CcymIuZPQXBpi7iw0l4GYuwjNZSHmrkJzOYi5m9BcHmLuLjRXgJh7CM0VIeaeQnMliLmX0FwZYu4tNFeBmPsIzYkQc6bQHIWY+wrNSRBzP6E5GWLOEppTIOb+QnMqxDxAaK4KMQ8UmtMg5kFCczrEPFhozoCYhwjN10PMQ4XmahDzMKG5OsQ8XGiuATGPEJprQsw3CM21IOYbhebaEPNNQnMdiPlmobkuxDxSaK4HMY8SmutDzLcIzQ0g5luF5oYQ821CcyOIebTQ3Bhivl1obgIx3yE0N4WY7xSam0HMdwnNzSHmu4XmFhDzPUJzS4j5XqG5FcR8n9DcGmK+X2huAzE/IDS3hZgfFJrbQcwPCc3tIeaHheYOEPMjQnNHiPlRobkTxPyY0NwZYn5caO4CMT8hNHeFmJ8UmrtBzE8Jzd0h5qeF5h4Q8zNCc0+I+VmhuRfE/JzQ3Btifl5o7gMxvyA0Z0LMLwrNfSHml4TmfhDzy0JzFsT8itDcH2J+VWgeADG/JjQPhJhfF5oHQcxvCM2DIeY3heYhEPNbQvNQiPltoXkYxPyO0DwcYn5XaB4BMb8nNN8AMb8vNN8IMX8gNN8EMX8oNN8MMX8kNI+EmD8WmkdBzJ8IzbdAzJ8KzbdCzJ8JzbdBzJ8LzaMh5i+E5tsh5i+F5jsg5q+E5jsh5q+F5rsg5m+E5rsh5m+F5nsg5u+E5nsh5u+F5vsg5h+E5vsh5jFC8wMQ81ih+UGIeZzQ/BDEPF5ofhhiniA0PwIxTxSaH4WYJwnNj0HMk4XmxyHmKULzExDzVKH5SYh5mtD8FMQ8XWh+GmKeITQ/AzHPFJqfhZhnCc3PQcyzhebnIeY5QvMLEPNcoflFiHme0PwSxDxfaH4ZYl4gNL8CMS8Uml+FmBcJza9BzIuF5tch5iVC8xsQ81Kh+U2IeZnQ/BbEvFxofhtiXiE0vwMxrxSa34WYVwnN70HMq4Xm9yHmNULzBxDzWqH5Q4h5ndD8EcS8Xmj+GGLeIDR/AjFvFJo/hZg3Cc2fQcybhebPIeYtQvMXEPNWoflLiHmb0PwVxLxdaP4aYt4hNH8DMe8Umr+FmHcJzd9BzLuF5u8h5j1C8w8Q816heQzEvE9oHgsx7xeax0HMB4Tm8RDzQaF5AsR8SGieCDEfFponQcxHhObJEPNRoXkKxHxMaJ4KMR8XmqdBzCeE5ukQ80mheQbEfEpongkxnxaaZ0HMPwrNsyHmn4TmORDzz0LzXIj5F6F5HsT8q9A8H2L+TWheADH/LjQvhJj/EJoXQcx/Cs2LIea/hOYlEPMZoXkpxPy30LwMYo7k0JmXQ8w5hOYVEHOc0LwSYo4XmldBzDmF5tUQc4LQvAZiziU0r4WYcwvN6yDmPELzeog5r9C8AWK+QGjeCDFfKDRvgpgvEpo3Q8wXC81bIOZLhOatEPOlQvM2iPkyoXk7xHy50LwDYr5CaN4JMV8pNO+CmK8SmndTjrcjOvMeyvG20LyXcrwtNO+jHG8Lzfspx9tC8wHK8bbQfJByvC00H6IcbwvNhynH20LzEcrxttB8lHK8LTQfoxxvC83HIearheYTEPM1QvNJiPlaofmU0JwvvJ8cwRxvk9MmwSaXTW6bPDb+e6H/nuS/N/hxtB9X+nGWH3f4z2H/ueTfp/37ln8d++e1/zu7+zqbfDEf221hvdr+0mtsrrW5ziafTX6bAjYFbQrZFLYpYlPUpphNcZsSNiVtStmUtiljU9amnE15mwo2FW0q2VS2qWKTaBO1SbJJtkmxSbWpapNmk26TYXO9TTWb6jY1bGra1PKPt00dm7o29Wzq2zSwaWjTyKaxTRObpjbNbJrbtLBpadPKprVNG5u2Nu1s2tt0sOlo08mms00Xm6423Wy62/Sw6WnTy6a3TR+bTJu+Nv1ssmz62wywGWgzyGawzRCboTbDbIbbjLDxe8P7vdL93uF+L22/t7Tfa9nvPez34vV70/q9Wv3epX4vT7+3pd/r0e996PcC9Hvj+b3i/N5pfi8xv7eW32vK773k9yLye/P4vWr83i1+LxO/t4ff68Lv/eD3QvB7A/he+b53vO+l7nuL+17bvve078XsexP7Xr2+d63v5ep7m/pen773pe8F6Xsj+l6Bvnee7yXne6v5XmO+95bvReV7M/leRb53j+9l43u7+F4nvveH74Xhe0P4Xgm+d4BfS+/Xlvu11n7tsV+L69em+rWafu2iX8vn17b5tV5+7ZNfC+TXxvi1In7thF9L4OfW+7nmfu61n4vs5+b6uap+7qafy+jn9vm5bn7ul58L5ecG+bkyfu6In0vh5xb4a+3+2rO/FuuvTfprdf7alb+W469t+HP9/ty3Pxfsz436c4X+3Jk/l+TPrfhzDf67t/8u6r+b+e8qfuzux7J+bOfHOv6z338W+s8G/17p3zuyH/8BtwN4HZ18AQA=", "verificationKey": "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" } ], @@ -32,21 +32,21 @@ "debug": { "debugSymbols": [ "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", - "eJzN1s1qwkAUhuF7mXWQnL/MTG6ldBFaC4LE0mQXcu9aSWzQqeNq+FYqnDm8EefByR1PH914OPWDaycnrn2b3PDd9b+fhrH7GV1bV27ff15e58p9HY5719JcPUyRmLdl8vI++tu0aGpcldfFpFbLdvy9cgpTYjAlDUyJhykJMCURpoRqnBTCSWGcFBxnCQdawpGWcKglHGsJB1vC0ZZxtGUcbRlHW8bRlnG0ZRxtGUdbxtGWcbRlHG0FR1vB0VZwtBUcbQVHWymprQW5pTRNvE8pqW0mpaS2mZSS2mZSSmr7PEVLaptJKaltJqWktpmUktpmUkpqm0nB0VZxtFUcbRVHW8XR1nC0taS2HNcYIXmaI+zXSfvbbeG6O8nn67s16DJpEra7E4/pwzLKYfOXzK4ZSTpfzzCNa4YP949Iu+S9Z17P8OPXQrvkBc2cSd6kzJnkT/7/M/N8BopaM4w=" + "eJzN1s2KwjAUhuF7ybpIz09M0lsZZlFGBwSpw7S70nsfR0wpGjmuwrdS4SS8Dc2DsztfvvrpdBlG181OXPcxu/GnH/5/jVP/O7mubdxxOFw/l8Z9n85H19HSPE1RIEr3yet3pXVatDie9prHY6thO/7ZOIUp8TAle5iSAFMSYUoSTAm1OCmEk8I4KTjOEg60hCMt4VBLONYSDraEoy3jaMs42jKOtoyjLeNoyzjaMo62jKMt42jLONoKjraCo63gaCs42gqOtlJR20gc1hQmeUypqK2VUlFbK6WitlZKRW2NFK2orZVSUVsrpaK2VkpFba2UitpaKTjaKo62iqOt4mirONp6HG19UVtOOUY2K0o5su4uPq2TPt72LvL5/t4a8z8tL3G7d+lU4n2U4+YR/S2jSOf7GV7zefsQHx+RdsV7z5zX8POx0K54QY01xZtkrCm+8q/XLMsfJBozLA==" ], "fileMap": { "34": { - "source": "use crate::constants_gen::{\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n\n // TODO: include globals in here and check them elsewhere\n // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n \n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.push_array(self.public_call_stack);\n inputs.push_array(self.new_commitments);\n inputs.push_array(self.new_nullifiers);\n inputs.push_array(self.new_l2_to_l1_msgs);\n\n // We do not include block_data since it's not in the cpp hash\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n fields.push_array(self.contract_storage_update_requests[i].serialize());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n fields.push_array(self.contract_storage_read[i].serialize());\n }\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/abi" + "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n GENERATOR_INDEX__SIDE_EFFECT,\n GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH,\n GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\nstruct SideEffect {\n value: Field,\n side_effect_counter: Field,\n}\nimpl SideEffect {\n fn serialize(self) -> [Field; 2] {\n [self.value, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 2]) -> Self {\n Self {\n value: values[0],\n side_effect_counter: values[1],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n side_effect_counter: 0,\n }\n }\n}\n\n// like read, nullifier, and possibly encrypted logs\n// (they may be linked to a note / note-hash)\nstruct SideEffectLinkedToNoteHash {\n value: Field,\n note_hash: Field, // e.g. noteHash\n side_effect_counter: Field,\n}\n\nimpl SideEffectLinkedToNoteHash {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.note_hash, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n note_hash: values[1],\n side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n note_hash: 0,\n side_effect_counter: 0,\n }\n }\n}\n\nstruct SideEffectWithRange {\n value: Field,\n start_side_effect_counter: Field,\n end_side_effect_counter: Field,\n}\n\nimpl SideEffectWithRange {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.start_side_effect_counter, self.end_side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n start_side_effect_counter: values[1],\n end_side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n start_side_effect_counter: 0,\n end_side_effect_counter: 0,\n }\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n\n start_side_effect_counter: Field,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n self.start_side_effect_counter,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [SideEffectWithRange; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.map_and_push_array(SideEffect::hash, self.read_requests);\n fields.map_and_push_array(SideEffect::hash, self.new_commitments);\n fields.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.map_and_push_array(SideEffectWithRange::hash, self.private_call_stack);\n fields.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n fields.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(SideEffect::serialize, self.read_requests);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n // TODO(dbanks12): should nullified commitments be here!\n fields.push_array(self.nullified_commitments);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0, side_effect_counter: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0, side_effect_counter: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicCircuitPublicInputs {\n\n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n inputs.map_and_push_array(SideEffect::hash, self.new_commitments);\n inputs.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n inputs.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize());\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(ContractStorageUpdateRequest::serialize, self.contract_storage_update_requests);\n fields.flatten_and_push_array(ContractStorageRead::serialize, self.contract_storage_read);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/abi" }, "35": { "source": "use dep::std::hash;\nuse crate::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n\npub fn compute_address(pub_key_x: Field, pub_key_y: Field, partial_address: Field) -> Field {\n hash::pedersen_with_separator([pub_key_x, pub_key_y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/address" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/address" }, "58": { "source": "use crate::types::point::Point;\nuse crate::address::compute_address;\n\n#[oracle(getPublicKey)]\nfn get_public_key_oracle(_address: Field) -> [Field; 3] {}\n\nunconstrained fn get_public_key_internal(address: Field) -> [Field; 3] {\n get_public_key_oracle(address)\n}\n\npub fn get_public_key(address: Field) -> Point {\n let result = get_public_key_internal(address);\n let pub_key_x = result[0];\n let pub_key_y = result[1];\n let partial_address = result[2];\n \n let calculated_address = compute_address(pub_key_x, pub_key_y, partial_address);\n assert(calculated_address == address);\n \n Point::new(pub_key_x, pub_key_y)\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" } } } -} +} \ No newline at end of file diff --git a/yarn-project/boxes/blank-react/src/artifacts/Blank.ts b/yarn-project/boxes/blank-react/src/artifacts/Blank.ts index 264ab2c785aa..90b262f5ab79 100644 --- a/yarn-project/boxes/blank-react/src/artifacts/Blank.ts +++ b/yarn-project/boxes/blank-react/src/artifacts/Blank.ts @@ -1,20 +1,8 @@ + /* Autogenerated file, do not edit! */ /* eslint-disable */ -import { - AztecAddress, - CompleteAddress, - Contract, - ContractBase, - ContractFunctionInteraction, - ContractMethod, - DeployMethod, - EthAddress, - FieldLike, - AztecAddressLike, - EthAddressLike, - Wallet, -} from '@aztec/aztec.js'; +import { AztecAddress, CompleteAddress, Contract, ContractBase, ContractFunctionInteraction, ContractMethod, DeployMethod, EthAddress, FieldLike, AztecAddressLike, EthAddressLike, Wallet } from '@aztec/aztec.js'; import { Fr, Point } from '@aztec/foundation/fields'; import { PXE, PublicKey } from '@aztec/types'; import { ContractArtifact } from '@aztec/foundation/abi'; @@ -25,43 +13,58 @@ export const BlankContractArtifact = BlankContractArtifactJson as ContractArtifa * Type-safe interface for contract Blank; */ export class BlankContract extends ContractBase { - private constructor(completeAddress: CompleteAddress, wallet: Wallet, portalContract = EthAddress.ZERO) { + + private constructor( + completeAddress: CompleteAddress, + wallet: Wallet, + portalContract = EthAddress.ZERO + ) { super(completeAddress, BlankContractArtifact, wallet, portalContract); } + + /** * Creates a contract instance. * @param address - The deployed contract's address. * @param wallet - The wallet to use when interacting with the contract. * @returns A promise that resolves to a new Contract instance. */ - public static async at(address: AztecAddress, wallet: Wallet) { + public static async at( + address: AztecAddress, + wallet: Wallet, + ) { return Contract.at(address, BlankContract.artifact, wallet) as Promise; } + /** * Creates a tx to deploy a new instance of this contract. */ - public static deploy(pxe: PXE) { + public static deploy(pxe: PXE, ) { return new DeployMethod(Point.ZERO, pxe, BlankContractArtifact, Array.from(arguments).slice(1)); } /** * Creates a tx to deploy a new instance of this contract using the specified public key to derive the address. */ - public static deployWithPublicKey(pxe: PXE, publicKey: PublicKey) { + public static deployWithPublicKey(pxe: PXE, publicKey: PublicKey, ) { return new DeployMethod(publicKey, pxe, BlankContractArtifact, Array.from(arguments).slice(2)); } + + /** * Returns this contract's artifact. */ public static get artifact(): ContractArtifact { return BlankContractArtifact; } + /** Type-safe wrappers for the public methods exposed by the contract. */ public methods!: { + /** getPublicKey(address: field) */ getPublicKey: ((address: FieldLike) => ContractFunctionInteraction) & Pick; }; diff --git a/yarn-project/boxes/blank/src/artifacts/Blank.json b/yarn-project/boxes/blank/src/artifacts/Blank.json index c0c7b983be1e..2c4c23e03a20 100644 --- a/yarn-project/boxes/blank/src/artifacts/Blank.json +++ b/yarn-project/boxes/blank/src/artifacts/Blank.json @@ -7,7 +7,7 @@ "isInternal": false, "parameters": [], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -24,7 +24,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" } ], @@ -32,21 +32,21 @@ "debug": { "debugSymbols": [ "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", - "eJzN1s1qwkAUhuF7mXWQnL/MTG6ldBFaC4LE0mQXcu9aSWzQqeNq+FYqnDm8EefByR1PH914OPWDaycnrn2b3PDd9b+fhrH7GV1bV27ff15e58p9HY5719JcPUyRmLdl8vI++tu0aGpcldfFpFbLdvy9cgpTYjAlDUyJhykJMCURpoRqnBTCSWGcFBxnCQdawpGWcKglHGsJB1vC0ZZxtGUcbRlHW8bRlnG0ZRxtGUdbxtGWcbRlHG0FR1vB0VZwtBUcbQVHWymprQW5pTRNvE8pqW0mpaS2mZSS2mZSSmr7PEVLaptJKaltJqWktpmUktpmUkpqm0nB0VZxtFUcbRVHW8XR1nC0taS2HNcYIXmaI+zXSfvbbeG6O8nn67s16DJpEra7E4/pwzLKYfOXzK4ZSTpfzzCNa4YP949Iu+S9Z17P8OPXQrvkBc2cSd6kzJnkT/7/M/N8BopaM4w=" + "eJzN1s2KwjAUhuF7ybpIz09M0lsZZlFGBwSpw7S70nsfR0wpGjmuwrdS4SS8Dc2DsztfvvrpdBlG181OXPcxu/GnH/5/jVP/O7mubdxxOFw/l8Z9n85H19HSPE1RIEr3yet3pXVatDie9prHY6thO/7ZOIUp8TAle5iSAFMSYUoSTAm1OCmEk8I4KTjOEg60hCMt4VBLONYSDraEoy3jaMs42jKOtoyjLeNoyzjaMo62jKMt42jLONoKjraCo63gaCs42gqOtlJR20gc1hQmeUypqK2VUlFbK6WitlZKRW2NFK2orZVSUVsrpaK2VkpFba2UitpaKTjaKo62iqOt4mirONp6HG19UVtOOUY2K0o5su4uPq2TPt72LvL5/t4a8z8tL3G7d+lU4n2U4+YR/S2jSOf7GV7zefsQHx+RdsV7z5zX8POx0K54QY01xZtkrCm+8q/XLMsfJBozLA==" ], "fileMap": { "34": { - "source": "use crate::constants_gen::{\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n\n // TODO: include globals in here and check them elsewhere\n // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n \n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.push_array(self.public_call_stack);\n inputs.push_array(self.new_commitments);\n inputs.push_array(self.new_nullifiers);\n inputs.push_array(self.new_l2_to_l1_msgs);\n\n // We do not include block_data since it's not in the cpp hash\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n fields.push_array(self.contract_storage_update_requests[i].serialize());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n fields.push_array(self.contract_storage_read[i].serialize());\n }\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/abi" + "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n GENERATOR_INDEX__SIDE_EFFECT,\n GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH,\n GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\nstruct SideEffect {\n value: Field,\n side_effect_counter: Field,\n}\nimpl SideEffect {\n fn serialize(self) -> [Field; 2] {\n [self.value, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 2]) -> Self {\n Self {\n value: values[0],\n side_effect_counter: values[1],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n side_effect_counter: 0,\n }\n }\n}\n\n// like read, nullifier, and possibly encrypted logs\n// (they may be linked to a note / note-hash)\nstruct SideEffectLinkedToNoteHash {\n value: Field,\n note_hash: Field, // e.g. noteHash\n side_effect_counter: Field,\n}\n\nimpl SideEffectLinkedToNoteHash {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.note_hash, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n note_hash: values[1],\n side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n note_hash: 0,\n side_effect_counter: 0,\n }\n }\n}\n\nstruct SideEffectWithRange {\n value: Field,\n start_side_effect_counter: Field,\n end_side_effect_counter: Field,\n}\n\nimpl SideEffectWithRange {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.start_side_effect_counter, self.end_side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n start_side_effect_counter: values[1],\n end_side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n start_side_effect_counter: 0,\n end_side_effect_counter: 0,\n }\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n\n start_side_effect_counter: Field,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n self.start_side_effect_counter,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [SideEffectWithRange; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.map_and_push_array(SideEffect::hash, self.read_requests);\n fields.map_and_push_array(SideEffect::hash, self.new_commitments);\n fields.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.map_and_push_array(SideEffectWithRange::hash, self.private_call_stack);\n fields.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n fields.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(SideEffect::serialize, self.read_requests);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n // TODO(dbanks12): should nullified commitments be here!\n fields.push_array(self.nullified_commitments);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0, side_effect_counter: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0, side_effect_counter: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicCircuitPublicInputs {\n\n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n inputs.map_and_push_array(SideEffect::hash, self.new_commitments);\n inputs.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n inputs.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize());\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(ContractStorageUpdateRequest::serialize, self.contract_storage_update_requests);\n fields.flatten_and_push_array(ContractStorageRead::serialize, self.contract_storage_read);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/abi" }, "35": { "source": "use dep::std::hash;\nuse crate::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n\npub fn compute_address(pub_key_x: Field, pub_key_y: Field, partial_address: Field) -> Field {\n hash::pedersen_with_separator([pub_key_x, pub_key_y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/address" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/address" }, "58": { "source": "use crate::types::point::Point;\nuse crate::address::compute_address;\n\n#[oracle(getPublicKey)]\nfn get_public_key_oracle(_address: Field) -> [Field; 3] {}\n\nunconstrained fn get_public_key_internal(address: Field) -> [Field; 3] {\n get_public_key_oracle(address)\n}\n\npub fn get_public_key(address: Field) -> Point {\n let result = get_public_key_internal(address);\n let pub_key_x = result[0];\n let pub_key_y = result[1];\n let partial_address = result[2];\n \n let calculated_address = compute_address(pub_key_x, pub_key_y, partial_address);\n assert(calculated_address == address);\n \n Point::new(pub_key_x, pub_key_y)\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" } } } -} +} \ No newline at end of file diff --git a/yarn-project/boxes/blank/src/artifacts/Blank.ts b/yarn-project/boxes/blank/src/artifacts/Blank.ts index 264ab2c785aa..90b262f5ab79 100644 --- a/yarn-project/boxes/blank/src/artifacts/Blank.ts +++ b/yarn-project/boxes/blank/src/artifacts/Blank.ts @@ -1,20 +1,8 @@ + /* Autogenerated file, do not edit! */ /* eslint-disable */ -import { - AztecAddress, - CompleteAddress, - Contract, - ContractBase, - ContractFunctionInteraction, - ContractMethod, - DeployMethod, - EthAddress, - FieldLike, - AztecAddressLike, - EthAddressLike, - Wallet, -} from '@aztec/aztec.js'; +import { AztecAddress, CompleteAddress, Contract, ContractBase, ContractFunctionInteraction, ContractMethod, DeployMethod, EthAddress, FieldLike, AztecAddressLike, EthAddressLike, Wallet } from '@aztec/aztec.js'; import { Fr, Point } from '@aztec/foundation/fields'; import { PXE, PublicKey } from '@aztec/types'; import { ContractArtifact } from '@aztec/foundation/abi'; @@ -25,43 +13,58 @@ export const BlankContractArtifact = BlankContractArtifactJson as ContractArtifa * Type-safe interface for contract Blank; */ export class BlankContract extends ContractBase { - private constructor(completeAddress: CompleteAddress, wallet: Wallet, portalContract = EthAddress.ZERO) { + + private constructor( + completeAddress: CompleteAddress, + wallet: Wallet, + portalContract = EthAddress.ZERO + ) { super(completeAddress, BlankContractArtifact, wallet, portalContract); } + + /** * Creates a contract instance. * @param address - The deployed contract's address. * @param wallet - The wallet to use when interacting with the contract. * @returns A promise that resolves to a new Contract instance. */ - public static async at(address: AztecAddress, wallet: Wallet) { + public static async at( + address: AztecAddress, + wallet: Wallet, + ) { return Contract.at(address, BlankContract.artifact, wallet) as Promise; } + /** * Creates a tx to deploy a new instance of this contract. */ - public static deploy(pxe: PXE) { + public static deploy(pxe: PXE, ) { return new DeployMethod(Point.ZERO, pxe, BlankContractArtifact, Array.from(arguments).slice(1)); } /** * Creates a tx to deploy a new instance of this contract using the specified public key to derive the address. */ - public static deployWithPublicKey(pxe: PXE, publicKey: PublicKey) { + public static deployWithPublicKey(pxe: PXE, publicKey: PublicKey, ) { return new DeployMethod(publicKey, pxe, BlankContractArtifact, Array.from(arguments).slice(2)); } + + /** * Returns this contract's artifact. */ public static get artifact(): ContractArtifact { return BlankContractArtifact; } + /** Type-safe wrappers for the public methods exposed by the contract. */ public methods!: { + /** getPublicKey(address: field) */ getPublicKey: ((address: FieldLike) => ContractFunctionInteraction) & Pick; }; diff --git a/yarn-project/boxes/private-token/src/artifacts/PrivateToken.json b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.json index 28a4d10b9154..3c6a2cd222e6 100644 --- a/yarn-project/boxes/private-token/src/artifacts/PrivateToken.json +++ b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.json @@ -48,7 +48,7 @@ } } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -72,7 +72,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -93,7 +93,7 @@ "kind": "field" } ], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -117,7 +117,7 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" }, { @@ -141,23 +141,23 @@ } ], "returnTypes": [], - "bytecode": "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", + "bytecode": "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", "verificationKey": "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" } ], "events": [], "debug": { "debugSymbols": [ - "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", - "eJzdmstuYjEMQP/lrhGKX3nwK6NZoGkrVaroaGCH+PfyaJIrMIkqdVK3K0BywrHDPfYF9tPL65/17vl1s51W+4mm1a/9tP273pxebXfrf7tp5RbT4+bh+HhYTE/PL4/TCg6LmyggCfIeeXyeQokm0cKZMW8MLI7m4b8XE5shETMk3gxJMEMSzZAkMyTg7KCAHRS0g2LHs2BHtGDHtGBHtWDHtWBHtmDHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmTHtmTHtmTHtmTHtjTSthKpoHifrlFG2raDMtK2HZSRtu2gjLRtB2WkbdsoPNK2HZSRtu2gjLRtB2WkbTsodmzLdmzLdmzLdmzLdmzLdmwrqm0BUyrvgdIEipj3j6FOQwGVUAT/HopcQfjMoar2CzhUz36EIwnkUOdiGySSFGbf3tXl7BLWD0i4MKtCNs6smts4s6p448xqLwCiyixxtvtpiers9hLVre0lqgOBAhdbIbRN6FwRoaO6fYxKsFDeV7jWKKbzb5y6Az+EwiXWRd9GIQpZ9ccCuXYwQKw1JD8/3dvgkPLGcRbKWl/gmEPn97Ci2tIlzLoE8PPiabyh8GLidnDDw17vBz/6TATKmXjXOZNyJIR1AmCNtlVkvdl9vyInKgZMNC/yKUm9O37vJON1kno7/WFJ6v33vyUZCwtF4U4whhwr9SqTS3+504MtcHMsfXHWQkVVe4hZJHH2tac/p3hnZrCQonD++EmI10dzZ3Axz/0J09NXcIfBo9ancQ8eRxLk0ZbdzINqMCYoOVYVH6fc85S91KXpyo0I1LJ4uEwFS/WqYMkzh0BVnL9MErJUJYeYa4q3WpSlao3OGpWts0a9WlprAiz1f7SJy4s81Xs9f5Tg4fAGGBl/jQ==", - "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", - "eJzdmtuKIjEQht+lr0VSpxx8lWUvZHcWBgZnWb0T330dNelerU4Y0FizVyr8CV+S9quKuB/e3n+sd6/vm+2w2g80rL7th+3v9ebj03a3/rMbVm4xvGx+Hl8Pi+HX69vLsILD4iYFJEEuyeP7FEqaRIszY54YWBxN498XA5shETMk3gxJMEMSzZAkMyTg7KCAHRS0g2LHs2BHtGDHtGBHtWDHtWBHtmDHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmjHtmTHtmTHtmTHtmTHttTTthKpoHifrlF62raB0tO2DZSetm2g9LRtA6Wnbeso3NO2DZSetm2g9LRtA6WnbRsodmzLdmzLdmzLdmzLdmzLdmwrqm0hYMqDgkgVKGKeP4axGwqoRBH8JYo8gvCJQ1XtEzhUz36GIwnkqHOxDhJJCrOvz+ry6hKOD0g4M6tCNs6smts4s6p448xqLYDgi0Oi47pwnCtZRyN0jEpYiC9Z4RElphOKWgs+h8JcUKKvoxCFbFSi5OphgFgOkchPN/E2HFKeOE6irOmXY45Or4qiSsklzFYC8NPN03hD4cXE9XBNd2pR/L/PRKCciXeNMylHQjgWWtZoa5uslvsvuMmJimgSTTf5uEg/00h86UXG60XOdCmPWiSnzELi/lHvB8xMq/IcmJke5DkwM83Fo2BieWQoCjfCGAr46Ak5VUg/02BY4OZYKvukCRC1OIWYVRgnv4/60xLv0I88aonC2RIS4vXRdG5e7sbducDfjbtzzbwXd+hcBhPkidmlWA9jgrLGsWIe+/TTPWGpy8eVGwuM3B7Ofc1SfbpYctckMCrO81nNS9UAWC5ReKtFXqrfvsYYla0xRn3qamOCW+p/fROXB3kaL4X+KMHD4S/T8oxP", - "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" + "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", + "eJzdmttqGzEQht9lr43RnHTwq5RemDaFQHBKnbvgd8/6IGmxxxKBVJnkKgn80n6S2G9Gdl6np+df25fH591+2rxONG1+vE77v9vd8a/9y/bfy7Rxq+lh93v+eVhNfx6fHqYNHFY3KQgA6ZKcf2coaRI1njzneHQclvGfq4nNkIgZEm+GJJghiWZIkhkScHZQwA4K2kGx41mwI1qwY1qwo1qw41qwI1uwY1u0Y1u0Y1u0Y1u0Y1u0Y1u0Y1u0Y1u0Y1u0Y1u0Y1uyY1uyY1uyY1uyY1saaNsIGAoKAl2jDLRtD2WgbXsoA23bQxlo2x7KQNt2UHigbXsoA23bQxlo2x7KQNv2UOzYlu3Ylu3Ylu3Ylu3Ylu3YVlTbAqbyDEJpAkWkSzSGOntAJYrgL1HkVKJ84lBV+wkcqmffw5EEctS52AaJJIXZt2fFeEkmrs8PZ2ZVyMaZVXMbZ1YVb5xZrQVAVJklLmY/DlGd3R6iurU9RHUgUCi3K0ZoLnveQim7SXX6GJWwUJ5XuAo2ptN3nLoD34XCJeuib6MQhaz6eYNcOwwIZWbysDzd23BIeeJIFYK1usAxR8VVW4pqS5cw6xLALzdP4Z0vyJkXE7fDDQ97vR586zMRKGfiXedMypEQ1o8gWKNtbbJe7L7eJifKtT8lWm7ycZF6dfzai4zXi9TL6TdbpF5//9siY2GhKNwJly6bpL5lcq4vd2qwBW6OpS4uSqioag+5zcC4uEb40xLv9AwWliicK5KEeH00dxoX89wf0D19BncY3Gp9GPfgdiRBbm3ZLTyohjFBWWNV8dzlnrrstS5NVy4iULfFw7krWKtvBUvuOQSq4vy5k5C1KjnEvKd4q0VZq9bojFHZOmPUt6U1JsBa/482cXmQp3rX8rMED4c3NJB/Gg==", + "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", + "eJzdmttqGzEQht9lr43RnHTwq5RemDaFQHBK7bvgd+9mY0muPbsiYMuTXiWBf+VP0uabGfDb8PL6Y3t4ft3th83bQMPm29uw/73dvf+1P2z/HIaNWw1Pu5/jz+Nq+PX88jRs4Li6SkEASKfk+DtDSZOo8eQ5x6PjcB7/vhrYDImYIfFmSIIZkmiGJJkhAWcHBeygoB0UO54FO6IFO6YFO6oFO64FO7IFO7ZFO7ZFO7ZFO7ZFO7ZFO7ZFO7ZFO7ZFO7ZFO7ZFO7YlO7YlO7YlO7YlO7aljraNgKGgINAlSkfbtlA62raF0tG2LZSOtm2hdLRtA4U72raF0tG2LZSOtm2hdLRtC8WObdmObdmObdmObdmObdmObUW1LQSsnyGyCBSRTtEY6uoBlSiCP0WRU4nyxKGq9gEcqmc/w5EEctS5uAwSSQqzX14V4ymZuH5++GBWhWycWTW3cWZV8caZ1VoAwUuRguNl4ThXso4qdIxKWCgPR8LVYzFNKGot+BwKl9nLRb+MQhSyUYmSWw4DQlmZPJwf4nU4pLxwpArBmn455qi4KiVRpeQSZisB+PPDU3jHOTTzYuLl8JLu1KL4f9+JQLkT7xp3Uq6EsE76rNEuHbJa7r/gISfKJTYlOj/kcZN+ppH40puMl5uc6VLutUlOmYXE/aPed5iZVuUxMDM9yGNgZpqLe8HE8spQFG6ESztOUj0hU4X0Mw2GBW6OpbKfNQGiFqeQ+xGMZ/OGn7Z4g37kXlsUzjVVQry8ms7Ny824Oxf4m3F3rpm34g6dy2CCvDC7FJfDmKDssVbMsU+f5oS1Lh9XJhao3GMNnfqatfp2seSuSaAqzvOHmteqAbAMUXitRV6r/32NZ1S2xjPqW7f0THBr/atv4vJDnupQ5kcJHo9/ARqoi+k=", + "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" ], "fileMap": { "1": { "source": "contract PrivateToken {\n use dep::std::option::Option;\n use dep::value_note::{\n balance_utils,\n utils::{increment, decrement},\n value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods},\n };\n use dep::aztec::{\n context::{PrivateContext, PublicContext, Context},\n note::{\n note_header::NoteHeader,\n utils as note_utils,\n },\n state_vars::{map::Map, set::Set},\n };\n\n struct Storage {\n // maps an aztec address to its balance\n balances: Map>,\n }\n\n impl Storage {\n fn init(context: Context) -> pub Self {\n Storage {\n balances: Map::new(\n context,\n 1, // Storage slot\n |context, slot| {\n Set::new(context, slot, ValueNoteMethods)\n },\n ),\n }\n }\n }\n\n // Constructs the contract and sets `initial_supply` which is fully owned by `owner`.\n #[aztec(private)]\n fn constructor(\n initial_supply: Field, \n owner: Field\n ) {\n \n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n if (initial_supply != 0) {\n increment(owner_balance, initial_supply, owner);\n }\n }\n\n // Mints `amount` of tokens to `owner`.\n #[aztec(private)]\n fn mint(\n amount: Field, \n owner: Field\n ) {\n \n\n // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call.\n let owner_balance = storage.balances.at(owner);\n increment(owner_balance, amount, owner);\n }\n\n // Transfers `amount` of tokens from msg_sender to a `recipient`.\n #[aztec(private)]\n fn transfer(\n amount: Field, \n recipient: Field,\n ) {\n \n let sender = context.msg_sender();\n\n // Pick from the set of sender's notes to spend amount.\n let sender_balance = storage.balances.at(sender);\n decrement(sender_balance, amount, sender);\n\n // Creates new note for the recipient.\n let recipient_balance = storage.balances.at(recipient);\n increment(recipient_balance, amount, recipient);\n }\n\n // Helper function to get the balance of a user (\"unconstrained\" is a Noir alternative of Solidity's \"view\" function).\n unconstrained fn getBalance(\n owner: Field,\n ) -> Field {\n \n\n // Get the set of notes owned by the user.\n let owner_balance = storage.balances.at(owner);\n\n // Return the sum of all notes in the set.\n balance_utils::get_balance(owner_balance)\n }\n\n // Computes note hash and nullifier.\n // Note 1: Needs to be defined by every contract producing logs.\n // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes.\n unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] {\n let note_header = NoteHeader::new(contract_address, nonce, storage_slot);\n note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage)\n }\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/boxes/private-token/src/contracts/src/main" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/boxes/private-token/src/contracts/src/main" }, "4": { "source": "mod poseidon;\n\n#[foreign(sha256)]\npub fn sha256(_input : [u8; N]) -> [u8; 32] {}\n\n#[foreign(blake2s)]\npub fn blake2s(_input : [u8; N]) -> [u8; 32] {}\n\npub fn pedersen(input : [Field; N]) -> [Field; 2] {\n pedersen_with_separator(input, 0)\n}\n\n#[foreign(pedersen)]\npub fn pedersen_with_separator(_input : [Field; N], _separator : u32) -> [Field; 2] {}\n\n#[foreign(hash_to_field_128_security)]\npub fn hash_to_field(_input : [Field; N]) -> Field {}\n\n#[foreign(keccak256)]\npub fn keccak256(_input : [u8; N], _message_size: u32) -> [u8; 32] {}\n\n// mimc-p/p implementation\n// constants are (publicly generated) random numbers, for instance using keccak as a ROM.\n// You must use constants generated for the native field\n// Rounds number should be ~ log(p)/log(exp)\n// For 254 bit primes, exponent 7 and 91 rounds seems to be recommended\nfn mimc(x: Field, k: Field, constants: [Field; N], exp : Field) -> Field {\n //round 0\n let mut t = x + k;\n let mut h = t.pow_32(exp);\n //next rounds\n for i in 1 .. constants.len() {\n t = h + k + constants[i];\n h = t.pow_32(exp);\n };\n h + k\n}\n\nglobal MIMC_BN254_ROUNDS = 91;\n\n//mimc implementation with hardcoded parameters for BN254 curve.\npub fn mimc_bn254(array: [Field; N]) -> Field {\n //mimc parameters\n let exponent = 7;\n //generated from seed \"mimc\" using keccak256 \n let constants: [Field; MIMC_BN254_ROUNDS] = [\n 0, \n 20888961410941983456478427210666206549300505294776164667214940546594746570981,\n 15265126113435022738560151911929040668591755459209400716467504685752745317193,\n 8334177627492981984476504167502758309043212251641796197711684499645635709656,\n 1374324219480165500871639364801692115397519265181803854177629327624133579404,\n 11442588683664344394633565859260176446561886575962616332903193988751292992472,\n 2558901189096558760448896669327086721003508630712968559048179091037845349145,\n 11189978595292752354820141775598510151189959177917284797737745690127318076389,\n 3262966573163560839685415914157855077211340576201936620532175028036746741754,\n 17029914891543225301403832095880481731551830725367286980611178737703889171730,\n 4614037031668406927330683909387957156531244689520944789503628527855167665518,\n 19647356996769918391113967168615123299113119185942498194367262335168397100658,\n 5040699236106090655289931820723926657076483236860546282406111821875672148900,\n 2632385916954580941368956176626336146806721642583847728103570779270161510514,\n 17691411851977575435597871505860208507285462834710151833948561098560743654671,\n 11482807709115676646560379017491661435505951727793345550942389701970904563183,\n 8360838254132998143349158726141014535383109403565779450210746881879715734773,\n 12663821244032248511491386323242575231591777785787269938928497649288048289525,\n 3067001377342968891237590775929219083706800062321980129409398033259904188058,\n 8536471869378957766675292398190944925664113548202769136103887479787957959589,\n 19825444354178182240559170937204690272111734703605805530888940813160705385792,\n 16703465144013840124940690347975638755097486902749048533167980887413919317592,\n 13061236261277650370863439564453267964462486225679643020432589226741411380501,\n 10864774797625152707517901967943775867717907803542223029967000416969007792571,\n 10035653564014594269791753415727486340557376923045841607746250017541686319774,\n 3446968588058668564420958894889124905706353937375068998436129414772610003289,\n 4653317306466493184743870159523234588955994456998076243468148492375236846006,\n 8486711143589723036499933521576871883500223198263343024003617825616410932026,\n 250710584458582618659378487568129931785810765264752039738223488321597070280,\n 2104159799604932521291371026105311735948154964200596636974609406977292675173,\n 16313562605837709339799839901240652934758303521543693857533755376563489378839,\n 6032365105133504724925793806318578936233045029919447519826248813478479197288,\n 14025118133847866722315446277964222215118620050302054655768867040006542798474,\n 7400123822125662712777833064081316757896757785777291653271747396958201309118,\n 1744432620323851751204287974553233986555641872755053103823939564833813704825,\n 8316378125659383262515151597439205374263247719876250938893842106722210729522,\n 6739722627047123650704294650168547689199576889424317598327664349670094847386,\n 21211457866117465531949733809706514799713333930924902519246949506964470524162,\n 13718112532745211817410303291774369209520657938741992779396229864894885156527,\n 5264534817993325015357427094323255342713527811596856940387954546330728068658,\n 18884137497114307927425084003812022333609937761793387700010402412840002189451,\n 5148596049900083984813839872929010525572543381981952060869301611018636120248,\n 19799686398774806587970184652860783461860993790013219899147141137827718662674,\n 19240878651604412704364448729659032944342952609050243268894572835672205984837,\n 10546185249390392695582524554167530669949955276893453512788278945742408153192,\n 5507959600969845538113649209272736011390582494851145043668969080335346810411,\n 18177751737739153338153217698774510185696788019377850245260475034576050820091,\n 19603444733183990109492724100282114612026332366576932662794133334264283907557,\n 10548274686824425401349248282213580046351514091431715597441736281987273193140,\n 1823201861560942974198127384034483127920205835821334101215923769688644479957,\n 11867589662193422187545516240823411225342068709600734253659804646934346124945,\n 18718569356736340558616379408444812528964066420519677106145092918482774343613,\n 10530777752259630125564678480897857853807637120039176813174150229243735996839,\n 20486583726592018813337145844457018474256372770211860618687961310422228379031,\n 12690713110714036569415168795200156516217175005650145422920562694422306200486,\n 17386427286863519095301372413760745749282643730629659997153085139065756667205,\n 2216432659854733047132347621569505613620980842043977268828076165669557467682,\n 6309765381643925252238633914530877025934201680691496500372265330505506717193,\n 20806323192073945401862788605803131761175139076694468214027227878952047793390,\n 4037040458505567977365391535756875199663510397600316887746139396052445718861,\n 19948974083684238245321361840704327952464170097132407924861169241740046562673,\n 845322671528508199439318170916419179535949348988022948153107378280175750024,\n 16222384601744433420585982239113457177459602187868460608565289920306145389382,\n 10232118865851112229330353999139005145127746617219324244541194256766741433339,\n 6699067738555349409504843460654299019000594109597429103342076743347235369120,\n 6220784880752427143725783746407285094967584864656399181815603544365010379208,\n 6129250029437675212264306655559561251995722990149771051304736001195288083309,\n 10773245783118750721454994239248013870822765715268323522295722350908043393604,\n 4490242021765793917495398271905043433053432245571325177153467194570741607167,\n 19596995117319480189066041930051006586888908165330319666010398892494684778526,\n 837850695495734270707668553360118467905109360511302468085569220634750561083,\n 11803922811376367215191737026157445294481406304781326649717082177394185903907,\n 10201298324909697255105265958780781450978049256931478989759448189112393506592,\n 13564695482314888817576351063608519127702411536552857463682060761575100923924,\n 9262808208636973454201420823766139682381973240743541030659775288508921362724,\n 173271062536305557219323722062711383294158572562695717740068656098441040230,\n 18120430890549410286417591505529104700901943324772175772035648111937818237369,\n 20484495168135072493552514219686101965206843697794133766912991150184337935627,\n 19155651295705203459475805213866664350848604323501251939850063308319753686505,\n 11971299749478202793661982361798418342615500543489781306376058267926437157297,\n 18285310723116790056148596536349375622245669010373674803854111592441823052978,\n 7069216248902547653615508023941692395371990416048967468982099270925308100727,\n 6465151453746412132599596984628739550147379072443683076388208843341824127379,\n 16143532858389170960690347742477978826830511669766530042104134302796355145785,\n 19362583304414853660976404410208489566967618125972377176980367224623492419647,\n 1702213613534733786921602839210290505213503664731919006932367875629005980493,\n 10781825404476535814285389902565833897646945212027592373510689209734812292327,\n 4212716923652881254737947578600828255798948993302968210248673545442808456151,\n 7594017890037021425366623750593200398174488805473151513558919864633711506220,\n 18979889247746272055963929241596362599320706910852082477600815822482192194401,\n 13602139229813231349386885113156901793661719180900395818909719758150455500533,\n ];\n\n let mut r = 0;\n for elem in array {\n let h = mimc(elem, r, constants, exponent);\n r = r + elem + h;\n }\n r\n}\n", @@ -172,93 +172,93 @@ "path": "std/grumpkin_scalar_mul" }, "35": { - "source": "use crate::constants_gen::{\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [Field; crate::abi::MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [Field; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [Field; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.push_array(self.read_requests);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.private_call_stack);\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value]\n }\n\n pub fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [Field; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [Field; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [Field; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [Field; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n\n // TODO: include globals in here and check them elsewhere\n // https://github.com/AztecProtocol/aztec-packages/issues/1567\n}\n\nimpl PublicCircuitPublicInputs {\n \n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.push_array(self.public_call_stack);\n inputs.push_array(self.new_commitments);\n inputs.push_array(self.new_nullifiers);\n inputs.push_array(self.new_l2_to_l1_msgs);\n\n // We do not include block_data since it's not in the cpp hash\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize()); // see https://github.com/AztecProtocol/aztec-packages/issues/1473\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n fields.push_array(self.contract_storage_update_requests[i].serialize());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n fields.push_array(self.contract_storage_read[i].serialize());\n }\n fields.push_array(self.public_call_stack);\n fields.push_array(self.new_commitments);\n fields.push_array(self.new_nullifiers);\n fields.push_array(self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/abi" + "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n RETURN_VALUES_LENGTH,\n MAX_READ_REQUESTS_PER_CALL,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n GENERATOR_INDEX__FUNCTION_ARGS,\n HISTORIC_BLOCK_DATA_LENGTH,\n CONTRACT_DEPLOYMENT_DATA_LENGTH,\n CALL_CONTEXT_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PRIVATE_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH,\n CONTRACT_STORAGE_READ_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH,\n PUBLIC_CIRCUIT_PUBLIC_INPUTS_HASH_INPUT_LENGTH,\n GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__FUNCTION_DATA,\n GENERATOR_INDEX__PUBLIC_DATA_READ,\n GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST,\n GENERATOR_INDEX__CALL_CONTEXT,\n GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS,\n GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA,\n GENERATOR_INDEX__SIDE_EFFECT,\n GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH,\n GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE,\n};\n\nuse crate::oracle::debug_log;\nuse crate::types::vec::BoundedVec;\nuse crate::types::point::Point;\n\n\n// docs:start:private-global-variables\nstruct PrivateGlobalVariables {\n chain_id: Field,\n version: Field,\n}\n// docs:end:private-global-variables\n\nimpl PrivateGlobalVariables {\n fn serialize(self) -> [Field; 2] {\n [self.chain_id, self.version]\n }\n}\n\n// docs:start:public-global-variables\nstruct PublicGlobalVariables {\n chain_id: Field,\n version: Field,\n block_number: Field,\n timestamp: Field,\n}\n// docs:end:public-global-variables\n\nimpl PublicGlobalVariables {\n fn serialize(self) -> [Field; 4] {\n [self.chain_id, self.version, self.block_number, self.timestamp]\n }\n}\n\nstruct SideEffect {\n value: Field,\n side_effect_counter: Field,\n}\nimpl SideEffect {\n fn serialize(self) -> [Field; 2] {\n [self.value, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 2]) -> Self {\n Self {\n value: values[0],\n side_effect_counter: values[1],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n side_effect_counter: 0,\n }\n }\n}\n\n// like read, nullifier, and possibly encrypted logs\n// (they may be linked to a note / note-hash)\nstruct SideEffectLinkedToNoteHash {\n value: Field,\n note_hash: Field, // e.g. noteHash\n side_effect_counter: Field,\n}\n\nimpl SideEffectLinkedToNoteHash {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.note_hash, self.side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n note_hash: values[1],\n side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_LINKED_TO_NOTE_HASH)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n note_hash: 0,\n side_effect_counter: 0,\n }\n }\n}\n\nstruct SideEffectWithRange {\n value: Field,\n start_side_effect_counter: Field,\n end_side_effect_counter: Field,\n}\n\nimpl SideEffectWithRange {\n fn serialize(self) -> [Field; 3] {\n [self.value, self.start_side_effect_counter, self.end_side_effect_counter]\n }\n\n fn deserialise(values: [Field; 3]) -> Self {\n Self {\n value: values[0],\n start_side_effect_counter: values[1],\n end_side_effect_counter: values[2],\n }\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__SIDE_EFFECT_WITH_RANGE)[0]\n }\n\n pub fn empty() -> Self {\n Self {\n value: 0,\n start_side_effect_counter: 0,\n end_side_effect_counter: 0,\n }\n }\n}\n\n// docs:start:contract-deployment-data\nstruct ContractDeploymentData {\n deployer_public_key: Point,\n constructor_vk_hash : Field,\n function_tree_root : Field,\n contract_address_salt : Field,\n portal_contract_address : Field,\n}\n// docs:end:contract-deployment-data\n\nimpl ContractDeploymentData {\n fn serialize(self) -> [Field; CONTRACT_DEPLOYMENT_DATA_LENGTH] {\n [\n self.deployer_public_key.x,\n self.deployer_public_key.y,\n self.constructor_vk_hash,\n self.function_tree_root,\n self.contract_address_salt,\n self.portal_contract_address,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CONTRACT_DEPLOYMENT_DATA)[0]\n }\n}\n\n// PrivateContextInputs are expected to be provided to each private function\n// docs:start:private-context-inputs\nstruct PrivateContextInputs {\n call_context : CallContext,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n private_global_variables: PrivateGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:private-context-inputs\n\n// PublicContextInputs are expected to be provided to each public function\n// docs:start:public-context-inputs\nstruct PublicContextInputs {\n call_context: CallContext,\n block_data: HistoricBlockData,\n\n public_global_variables: PublicGlobalVariables,\n\n // TODO(dbanks12): needed?\n start_side_effect_counter: Field,\n}\n// docs:end:public-context-inputs\n\n// docs:start:call-context\nstruct CallContext {\n msg_sender : Field,\n storage_contract_address : Field,\n portal_contract_address : Field,\n function_selector: Field,\n\n is_delegate_call : bool,\n is_static_call : bool,\n is_contract_deployment: bool,\n\n start_side_effect_counter: Field,\n}\n// docs:end:call-context\n\nimpl CallContext {\n fn serialize(self) -> [Field; CALL_CONTEXT_LENGTH] {\n [\n self.msg_sender,\n self.storage_contract_address,\n self.portal_contract_address,\n self.function_selector,\n self.is_delegate_call as Field,\n self.is_static_call as Field,\n self.is_contract_deployment as Field,\n self.start_side_effect_counter,\n ]\n }\n\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__CALL_CONTEXT)[0]\n }\n}\n\n// docs:start:historic-block-data\nstruct HistoricBlockData {\n private_data_tree_root : Field,\n nullifier_tree_root : Field,\n contract_tree_root : Field,\n l1_to_l2_messages_tree_root : Field,\n blocks_tree_root: Field,\n public_data_tree_root: Field,\n global_variables_hash: Field,\n}\n// docs:end:historic-block-data\n\nimpl HistoricBlockData {\n // NOTE: this order must match the order in `private_circuit_public_inputs.hpp`\n pub fn serialize(self) -> [Field; HISTORIC_BLOCK_DATA_LENGTH] {\n [\n self.private_data_tree_root,\n self.nullifier_tree_root,\n self.contract_tree_root,\n self.l1_to_l2_messages_tree_root,\n self.blocks_tree_root,\n self.public_data_tree_root,\n self.global_variables_hash,\n ]\n }\n\n pub fn empty() -> Self {\n Self { private_data_tree_root: 0, nullifier_tree_root: 0, contract_tree_root: 0, l1_to_l2_messages_tree_root: 0, blocks_tree_root: 0, public_data_tree_root: 0, global_variables_hash: 0 }\n }\n}\n\nstruct FunctionData {\n function_selector: Field,\n is_internal: bool,\n is_private: bool,\n is_constructor: bool,\n}\n\nimpl FunctionData {\n fn hash(self) -> Field {\n dep::std::hash::pedersen_with_separator([\n self.function_selector,\n self.is_internal as Field,\n self.is_private as Field,\n self.is_constructor as Field,\n ], GENERATOR_INDEX__FUNCTION_DATA)[0]\n }\n}\n\nstruct PrivateCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n read_requests: [SideEffect; MAX_READ_REQUESTS_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; MAX_NEW_NULLIFIERS_PER_CALL],\n nullified_commitments: [Field; MAX_NEW_NULLIFIERS_PER_CALL],\n private_call_stack: [SideEffectWithRange; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n // Explore introducing a new type like uint256 (similar to Point), so it's more explicit that\n // we're talking about a single number backed by two field elements.\n encrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n encrypted_log_preimages_length: Field,\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n contract_deployment_data: ContractDeploymentData,\n chain_id: Field,\n version: Field,\n}\n\nimpl PrivateCircuitPublicInputs {\n fn hash(self) -> Field {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push(self.call_context.hash());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.map_and_push_array(SideEffect::hash, self.read_requests);\n fields.map_and_push_array(SideEffect::hash, self.new_commitments);\n fields.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n fields.push_array(self.nullified_commitments);\n fields.map_and_push_array(SideEffectWithRange::hash, self.private_call_stack);\n fields.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n fields.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.contract_deployment_data.hash());\n fields.push(self.chain_id);\n fields.push(self.version);\n\n dep::std::hash::pedersen_with_separator(fields.storage, GENERATOR_INDEX__PRIVATE_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n fn serialize(self) -> [Field; PRIVATE_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize());\n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(SideEffect::serialize, self.read_requests);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n // TODO(dbanks12): should nullified commitments be here!\n fields.push_array(self.nullified_commitments);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.private_call_stack);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.encrypted_logs_hash);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.encrypted_log_preimages_length);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push_array(self.contract_deployment_data.serialize());\n fields.push(self.chain_id);\n fields.push(self.version);\n fields.storage\n }\n}\n\nstruct ContractStorageRead {\n storage_slot: Field,\n value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageRead {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_READ_LENGTH] {\n [self.storage_slot, self.value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_READ)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, value: 0, side_effect_counter: 0 }\n }\n}\n\nstruct ContractStorageUpdateRequest {\n storage_slot: Field,\n old_value: Field,\n new_value: Field,\n side_effect_counter: Field,\n}\n\nimpl ContractStorageUpdateRequest {\n pub fn serialize(self) -> [Field; CONTRACT_STORAGE_UPDATE_REQUEST_LENGTH] {\n [self.storage_slot, self.old_value, self.new_value, self.side_effect_counter]\n }\n\n pub fn hash(self) -> Field {\n // TODO(dbanks12): do we include side-effect counter in hash?\n dep::std::hash::pedersen_with_separator(self.serialize(), GENERATOR_INDEX__PUBLIC_DATA_UPDATE_REQUEST)[0]\n }\n\n pub fn empty() -> Self {\n Self { storage_slot: 0, old_value: 0, new_value: 0, side_effect_counter: 0 }\n }\n}\n\n\nstruct PublicCircuitPublicInputs {\n call_context: CallContext,\n args_hash: Field,\n return_values: [Field; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest; MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead; MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [SideEffectWithRange; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [SideEffect; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash; crate::abi::MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs: [SideEffect; crate::abi::MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash: [Field; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: Field,\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicCircuitPublicInputs {\n\n pub fn hash(self) -> Field {\n let mut inputs: BoundedVec = BoundedVec::new(0);\n inputs.push(self.call_context.hash());\n inputs.push(self.args_hash);\n inputs.push_array(self.return_values);\n for i in 0..MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL {\n inputs.push(self.contract_storage_update_requests[i].hash());\n }\n for i in 0..MAX_PUBLIC_DATA_READS_PER_CALL {\n inputs.push(self.contract_storage_read[i].hash());\n }\n inputs.map_and_push_array(SideEffectWithRange::hash, self.public_call_stack);\n inputs.map_and_push_array(SideEffect::hash, self.new_commitments);\n inputs.map_and_push_array(SideEffectLinkedToNoteHash::hash, self.new_nullifiers);\n inputs.map_and_push_array(SideEffect::hash, self.new_l2_to_l1_msgs);\n\n inputs.push_array(self.unencrypted_logs_hash);\n inputs.push(self.unencrypted_log_preimages_length);\n inputs.push_array(self.block_data.serialize());\n inputs.push(self.prover_address);\n\n dep::std::hash::pedersen_with_separator(inputs.storage, GENERATOR_INDEX__PUBLIC_CIRCUIT_PUBLIC_INPUTS)[0]\n }\n\n pub fn serialize(self) -> [Field; PUBLIC_CIRCUIT_PUBLIC_INPUTS_LENGTH] {\n let mut fields: BoundedVec = BoundedVec::new(0); \n fields.push_array(self.call_context.serialize()); \n fields.push(self.args_hash);\n fields.push_array(self.return_values);\n fields.flatten_and_push_array(ContractStorageUpdateRequest::serialize, self.contract_storage_update_requests);\n fields.flatten_and_push_array(ContractStorageRead::serialize, self.contract_storage_read);\n fields.flatten_and_push_array(SideEffectWithRange::serialize, self.public_call_stack);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_commitments);\n fields.flatten_and_push_array(SideEffectLinkedToNoteHash::serialize, self.new_nullifiers);\n fields.flatten_and_push_array(SideEffect::serialize, self.new_l2_to_l1_msgs);\n fields.push_array(self.unencrypted_logs_hash);\n fields.push(self.unencrypted_log_preimages_length);\n fields.push_array(self.block_data.serialize());\n fields.push(self.prover_address);\n fields.storage\n }\n}\n\nstruct Hasher {\n fields: [Field],\n}\n\nimpl Hasher {\n pub fn new()-> Self {\n Self { fields: [] }\n }\n\n pub fn add(&mut self, field: Field) {\n self.fields = self.fields.push_back(field);\n }\n\n pub fn add_multiple(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n\n pub fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nglobal ARGS_HASH_CHUNK_LENGTH: u32 = 32;\nglobal ARGS_HASH_CHUNK_COUNT: u32 = 16;\n\npub fn hash_args(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n let mut chunks_hashes = [0; ARGS_HASH_CHUNK_COUNT];\n for i in 0..ARGS_HASH_CHUNK_COUNT {\n let mut chunk_hash = 0;\n let start_chunk_index = i * ARGS_HASH_CHUNK_LENGTH;\n if start_chunk_index < (args.len() as u32) {\n let mut chunk_args = [0; ARGS_HASH_CHUNK_LENGTH];\n for j in 0..ARGS_HASH_CHUNK_LENGTH {\n let item_index = i * ARGS_HASH_CHUNK_LENGTH + j;\n if item_index < (args.len() as u32) {\n chunk_args[j] = args[item_index];\n }\n }\n chunk_hash = dep::std::hash::pedersen_with_separator(chunk_args, GENERATOR_INDEX__FUNCTION_ARGS)[0];\n }\n chunks_hashes[i] = chunk_hash;\n }\n dep::std::hash::pedersen_with_separator(chunks_hashes, GENERATOR_INDEX__FUNCTION_ARGS)[0]\n }\n}\n", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/abi" }, "36": { "source": "use dep::std::hash;\nuse crate::constants_gen::GENERATOR_INDEX__CONTRACT_ADDRESS;\n\npub fn compute_address(pub_key_x: Field, pub_key_y: Field, partial_address: Field) -> Field {\n hash::pedersen_with_separator([pub_key_x, pub_key_y, partial_address], GENERATOR_INDEX__CONTRACT_ADDRESS)[0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/address" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/address" }, "38": { - "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_READ_REQUESTS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n RETURN_VALUES_LENGTH,\n};\n\nuse crate::abi;\n\nuse crate::abi::{\n hash_args,\n CallContext,\n ContractDeploymentData,\n HistoricBlockData,\n FunctionData,\n PrivateCircuitPublicInputs,\n PublicCircuitPublicInputs,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// l1 to l2 messaging\nuse crate::messaging::process_l1_to_l2_message;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;\n\nuse crate::types::{\n vec::BoundedVec,\n point::Point,\n};\n\nuse crate::utils::arr_copy_slice;\n\nuse crate::oracle::{\n arguments,\n call_private_function::call_private_function_internal,\n public_call::call_public_function_internal,\n enqueue_public_function_call::enqueue_public_function_call_internal,\n context::get_portal_address,\n};\n\nuse dep::std::option::Option;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n // docs:start:private-context\n inputs: abi::PrivateContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n // docs:end:private-context\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\n}\n\nimpl PrivateContext {\n pub fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n read_requests: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n nullified_commitments: BoundedVec::new(0),\n\n block_data: inputs.block_data,\n\n private_call_stack: BoundedVec::new(0),\n public_call_stack: BoundedVec::new(0),\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n pub fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n pub fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.private_global_variables.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.private_global_variables.version\n }\n\n pub fn selector(self) -> Field {\n self.inputs.call_context.function_selector\n }\n\n pub fn finish(self) -> abi::PrivateCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let encrypted_log_preimages_length = 0;\n let unencrypted_log_preimages_length = 0;\n\n let priv_circuit_pub_inputs = abi::PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n return_values: self.return_values.storage,\n read_requests: self.read_requests.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n nullified_commitments: self.nullified_commitments.storage,\n private_call_stack: self.private_call_stack.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n encrypted_logs_hash: encrypted_logs_hash,\n unencrypted_logs_hash: unencrypted_logs_hash,\n encrypted_log_preimages_length: encrypted_log_preimages_length,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.block_data,\n contract_deployment_data: self.inputs.contract_deployment_data,\n chain_id: self.inputs.private_global_variables.chain_id,\n version: self.inputs.private_global_variables.version,\n };\n priv_circuit_pub_inputs\n }\n\n pub fn push_read_request(&mut self, read_request: Field) {\n self.read_requests.push(read_request);\n }\n\n pub fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n // We never push a zero nullified_commitment as zero is used to indicate the end\n // of a field array in private kernel. This routine transparently replaces a\n // zero value into the special placeholder: EMPTY_NULLIFIED_COMMITMENT.\n pub fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n let mut non_zero_nullified = nullified_commitment;\n if (non_zero_nullified == 0) {\n non_zero_nullified = EMPTY_NULLIFIED_COMMITMENT;\n }\n self.nullified_commitments.push(non_zero_nullified);\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, content: Field) \n // docs:end:context_message_portal\n {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n msg_key: Field,\n content: Field,\n secret: Field\n ) \n // docs:end:context_consume_l1_to_l2_message\n {\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, self.this_address(), msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n ) -> [Field; RETURN_VALUES_LENGTH] {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n pub fn call_private_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let fields = call_private_function_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PrivateCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PrivateCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n function_selector: fields[8], // practically same as fields[1]\n is_delegate_call : fields[9] as bool,\n is_static_call : fields[10] as bool,\n is_contract_deployment: fields[11] as bool,\n },\n // TODO handle the offsets as a variable incremented during extraction?\n args_hash: fields[12],\n return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 13),\n read_requests: arr_copy_slice(fields, [0; MAX_READ_REQUESTS_PER_CALL], 17),\n new_commitments: arr_copy_slice(fields, [0; MAX_NEW_COMMITMENTS_PER_CALL], 49),\n new_nullifiers: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 65),\n nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 81),\n private_call_stack: arr_copy_slice(fields, [0; MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], 97),\n public_call_stack: arr_copy_slice(fields, [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], 101),\n new_l2_to_l1_msgs: arr_copy_slice(fields, [0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL], 105),\n encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 107),\n unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 109),\n encrypted_log_preimages_length: fields[111],\n unencrypted_log_preimages_length: fields[112],\n block_data: HistoricBlockData {\n // Must match order in `private_circuit_public_inputs.hpp`\n private_data_tree_root : fields[113],\n nullifier_tree_root : fields[114],\n contract_tree_root : fields[115],\n l1_to_l2_messages_tree_root : fields[116],\n blocks_tree_root : fields[117],\n public_data_tree_root: fields[118],\n global_variables_hash: fields[119],\n },\n contract_deployment_data: ContractDeploymentData {\n deployer_public_key: Point::new(fields[120], fields[121]),\n constructor_vk_hash : fields[122],\n function_tree_root : fields[123],\n contract_address_salt : fields[124],\n portal_contract_address : fields[125],\n },\n chain_id: fields[126],\n version: fields[127],\n },\n is_execution_request: fields[128] as bool,\n };\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n\n assert(args_hash == item.public_inputs.args_hash);\n\n assert(item.is_execution_request == false);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.private_call_stack.push(item.hash());\n\n item.public_inputs.return_values\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field,\n ) {\n self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n pub fn call_public_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) {\n let fields = enqueue_public_function_call_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PublicCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PublicCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n function_selector: fields[8], // practically same as fields[1]\n is_delegate_call : fields[9] as bool,\n is_static_call : fields[10] as bool,\n is_contract_deployment: fields[11] as bool,\n },\n args_hash: fields[12],\n return_values: [0; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [0; MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [0; MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [0; MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs:[0; MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: 0,\n block_data: HistoricBlockData::empty(),\n prover_address: 0,\n },\n is_execution_request: true,\n };\n\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n \n assert(args_hash == item.public_inputs.args_hash);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n self.public_call_stack.push(item.hash());\n }\n}\n\nuse crate::abi::{\n ContractStorageRead,\n ContractStorageUpdateRequest\n};\n\nstruct PublicContext {\n inputs: abi::PublicContextInputs,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\n unencrypted_logs_preimages_length: Field,\n\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicContext {\n pub fn new(inputs: abi::PublicContextInputs, args_hash: Field) -> PublicContext {\n let empty_storage_read = ContractStorageRead::empty();\n let empty_storage_update = ContractStorageUpdateRequest::empty();\n PublicContext {\n inputs: inputs,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n contract_storage_read: BoundedVec::new(empty_storage_read),\n public_call_stack: BoundedVec::new(0),\n\n new_commitments: BoundedVec::new(0),\n new_nullifiers: BoundedVec::new(0),\n\n new_l2_to_l1_msgs: BoundedVec::new(0),\n\n \n unencrypted_logs_hash: BoundedVec::new(0),\n unencrypted_logs_preimages_length: 0,\n\n block_data: inputs.block_data,\n prover_address: 0,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n pub fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n pub fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.public_global_variables.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.public_global_variables.version\n }\n\n pub fn selector(self) -> Field {\n self.inputs.call_context.function_selector\n }\n\n pub fn block_number(self) -> Field {\n self.inputs.public_global_variables.block_number\n }\n\n pub fn timestamp(self) -> Field {\n self.inputs.public_global_variables.timestamp\n }\n\n pub fn finish(self) -> abi::PublicCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_log_preimages_length = 0;\n\n\n // Compute the public call stack hashes\n let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs {\n call_context: self.inputs.call_context, // Done\n args_hash: self.args_hash, // Done\n contract_storage_update_requests: self.contract_storage_update_requests.storage,\n contract_storage_read: self.contract_storage_read.storage,\n return_values: self.return_values.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n unencrypted_logs_hash: unencrypted_logs_hash,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.inputs.block_data,\n prover_address: self.prover_address,\n };\n pub_circuit_pub_inputs\n }\n\n pub fn push_new_note_hash(&mut self, note_hash: Field) {\n self.new_commitments.push(note_hash);\n }\n\n pub fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n self.new_nullifiers.push(nullifier);\n }\n\n pub fn message_portal(&mut self, content: Field) {\n self.new_l2_to_l1_msgs.push(content);\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n pub fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n let this = (*self).this_address();\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, this, msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n\n pub fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn call_public_function(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n args: [Field; ARGS_COUNT],\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = abi::hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n call_public_function_internal(\n contract_address, \n function_selector, \n args_hash,\n )\n }\n\n pub fn call_public_function_no_args(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n ) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_internal(\n contract_address, \n function_selector, \n 0,\n )\n }\n\n}\n\nstruct Context {\n private: Option<&mut PrivateContext>,\n public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n pub fn private(context: &mut PrivateContext) -> Context {\n Context {\n private: Option::some(context),\n public: Option::none()\n }\n }\n\n pub fn public(context: &mut PublicContext) -> Context {\n Context {\n public: Option::some(context),\n private: Option::none()\n }\n }\n\n pub fn none() -> Context {\n Context {\n public: Option::none(),\n private: Option::none()\n }\n }\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/context" + "source": "use crate::constants_gen::{\n EMPTY_NULLIFIED_COMMITMENT,\n MAX_NEW_COMMITMENTS_PER_CALL,\n MAX_NEW_L2_TO_L1_MSGS_PER_CALL,\n MAX_NEW_NULLIFIERS_PER_CALL,\n MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,\n MAX_PUBLIC_DATA_READS_PER_CALL,\n MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL,\n MAX_READ_REQUESTS_PER_CALL,\n NUM_FIELDS_PER_SHA256,\n RETURN_VALUES_LENGTH,\n};\n\nuse crate::abi;\n\nuse crate::abi::{\n hash_args,\n CallContext,\n ContractDeploymentData,\n HistoricBlockData,\n FunctionData,\n PrivateCircuitPublicInputs,\n PublicCircuitPublicInputs,\n SideEffect,\n SideEffectLinkedToNoteHash,\n SideEffectWithRange,\n};\n\n// TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n// use dep::std::collections::vec::Vec;\n\n// l1 to l2 messaging\nuse crate::messaging::process_l1_to_l2_message;\nuse crate::private_call_stack_item::PrivateCallStackItem;\nuse crate::public_call_stack_item::PublicCallStackItem;\n\nuse crate::types::{\n vec::BoundedVec,\n point::Point,\n};\n\nuse crate::utils::{arr_copy_slice, arr_copy_slice_in_struct_dumb2, arr_copy_slice_in_struct_dumb3};\n\nuse crate::oracle::{\n arguments,\n call_private_function::call_private_function_internal,\n public_call::call_public_function_internal,\n enqueue_public_function_call::enqueue_public_function_call_internal,\n context::get_portal_address,\n};\n\nuse dep::std::option::Option;\n\n// When finished, one can call .finish() to convert back to the abi\nstruct PrivateContext {\n // docs:start:private-context\n inputs: abi::PrivateContextInputs,\n side_effect_counter: Field,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n read_requests: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n // TODO(dbanks12): remove me!\n nullified_commitments: BoundedVec,\n\n private_call_stack : BoundedVec,\n public_call_stack : BoundedVec,\n new_l2_to_l1_msgs : BoundedVec,\n // docs:end:private-context\n\n block_data: HistoricBlockData,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec,\n // unencrypted_logs_preimages: Vec,\n}\n\nimpl PrivateContext {\n pub fn new(inputs: abi::PrivateContextInputs, args_hash: Field) -> PrivateContext {\n PrivateContext {\n inputs: inputs,\n // starts at 1 because all private calls have txhash nullifier as 0th nullifier\n // and therefore 0th sideeffect\n // increments for each side effect in this context\n side_effect_counter: 1,\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n read_requests: BoundedVec::new(SideEffect::empty()),\n\n new_commitments: BoundedVec::new(SideEffect::empty()),\n new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n // TODO(dbanks12): remove me!\n nullified_commitments: BoundedVec::new(0),\n\n block_data: inputs.block_data,\n\n private_call_stack: BoundedVec::new(SideEffectWithRange::empty()),\n public_call_stack: BoundedVec::new(SideEffectWithRange::empty()),\n new_l2_to_l1_msgs: BoundedVec::new(SideEffect::empty()),\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n pub fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n pub fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.private_global_variables.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.private_global_variables.version\n }\n\n pub fn selector(self) -> Field {\n self.inputs.call_context.function_selector\n }\n\n pub fn finish(self) -> abi::PrivateCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let encrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let encrypted_log_preimages_length = 0;\n let unencrypted_log_preimages_length = 0;\n\n let priv_circuit_pub_inputs = abi::PrivateCircuitPublicInputs {\n call_context: self.inputs.call_context,\n args_hash: self.args_hash,\n return_values: self.return_values.storage,\n read_requests: self.read_requests.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n // TODO(dbanks12): remove me!\n nullified_commitments: self.nullified_commitments.storage,\n private_call_stack: self.private_call_stack.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n encrypted_logs_hash: encrypted_logs_hash,\n unencrypted_logs_hash: unencrypted_logs_hash,\n encrypted_log_preimages_length: encrypted_log_preimages_length,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.block_data,\n contract_deployment_data: self.inputs.contract_deployment_data,\n chain_id: self.inputs.private_global_variables.chain_id,\n version: self.inputs.private_global_variables.version,\n };\n priv_circuit_pub_inputs\n }\n\n pub fn push_read_request(&mut self, read_request: Field) {\n let side_effect = SideEffect {\n value: read_request,\n side_effect_counter: self.side_effect_counter\n };\n self.read_requests.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n pub fn push_new_note_hash(&mut self, note_hash: Field) {\n let side_effect = SideEffect {\n value: note_hash,\n side_effect_counter: self.side_effect_counter\n };\n self.new_commitments.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n // We never push a zero nullified_commitment as zero is used to indicate the end\n // of a field array in private kernel. This routine transparently replaces a\n // zero value into the special placeholder: EMPTY_NULLIFIED_COMMITMENT.\n pub fn push_new_nullifier(&mut self, nullifier: Field, nullified_commitment: Field) {\n let mut non_zero_nullified = nullified_commitment;\n if (non_zero_nullified == 0) {\n non_zero_nullified = EMPTY_NULLIFIED_COMMITMENT;\n }\n let side_effect = SideEffectLinkedToNoteHash {\n value: nullifier,\n note_hash: non_zero_nullified,\n side_effect_counter: self.side_effect_counter\n };\n self.new_nullifiers.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n // TODO(dbanks12): remove me!\n self.nullified_commitments.push(non_zero_nullified);\n }\n\n // docs:start:context_message_portal\n pub fn message_portal(&mut self, content: Field) \n // docs:end:context_message_portal\n {\n let side_effect = SideEffect {\n value: content,\n side_effect_counter: self.side_effect_counter\n };\n self.new_l2_to_l1_msgs.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n // docs:start:context_consume_l1_to_l2_message\n // docs:start:consume_l1_to_l2_message\n pub fn consume_l1_to_l2_message(\n &mut self,\n msg_key: Field,\n content: Field,\n secret: Field\n ) \n // docs:end:context_consume_l1_to_l2_message\n {\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, self.this_address(), msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n // docs:end:consume_l1_to_l2_message\n\n pub fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self.inputs;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn call_private_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_private_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n pub fn call_private_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n ) -> [Field; RETURN_VALUES_LENGTH] {\n self.call_private_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n pub fn call_private_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let fields = call_private_function_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PrivateCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PrivateCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n function_selector: fields[8], // practically same as fields[1]\n is_delegate_call : fields[9] as bool,\n is_static_call : fields[10] as bool,\n is_contract_deployment: fields[11] as bool,\n start_side_effect_counter: fields[12],\n },\n // TODO handle the offsets as a variable incremented during extraction?\n args_hash: fields[13],\n return_values: arr_copy_slice(fields, [0; RETURN_VALUES_LENGTH], 14),\n read_requests: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_READ_REQUESTS_PER_CALL], SideEffect::deserialise, 18),\n new_commitments: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL], SideEffect::deserialise, 82),\n new_nullifiers: arr_copy_slice_in_struct_dumb3(fields, [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL], SideEffectLinkedToNoteHash::deserialise, 114),\n // TODO(dbanks12): remove me!\n nullified_commitments: arr_copy_slice(fields, [0; MAX_NEW_NULLIFIERS_PER_CALL], 162),\n private_call_stack: arr_copy_slice_in_struct_dumb3(fields, [SideEffectWithRange::empty(); MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL], SideEffectWithRange::deserialise, 178),\n public_call_stack: arr_copy_slice_in_struct_dumb3(fields, [SideEffectWithRange::empty(); MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL], SideEffectWithRange::deserialise, 190),\n new_l2_to_l1_msgs: arr_copy_slice_in_struct_dumb2(fields, [SideEffect::empty(); MAX_NEW_L2_TO_L1_MSGS_PER_CALL], SideEffect::deserialise, 202),\n encrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 206),\n unencrypted_logs_hash: arr_copy_slice(fields, [0; NUM_FIELDS_PER_SHA256], 208),\n encrypted_log_preimages_length: fields[210],\n unencrypted_log_preimages_length: fields[211],\n block_data: HistoricBlockData {\n // Must match order in `private_circuit_public_inputs.hpp`\n private_data_tree_root : fields[212],\n nullifier_tree_root : fields[213],\n contract_tree_root : fields[214],\n l1_to_l2_messages_tree_root : fields[215],\n blocks_tree_root : fields[216],\n public_data_tree_root: fields[217],\n global_variables_hash: fields[218],\n },\n contract_deployment_data: ContractDeploymentData {\n deployer_public_key: Point::new(fields[219], fields[220]),\n constructor_vk_hash : fields[221],\n function_tree_root : fields[222],\n contract_address_salt : fields[223],\n portal_contract_address : fields[224],\n },\n chain_id: fields[225],\n version: fields[226],\n },\n is_execution_request: fields[226] as bool,\n };\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n\n assert(args_hash == item.public_inputs.args_hash);\n\n assert(item.is_execution_request == false);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n let side_effect = SideEffectWithRange {\n value: item.hash(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n };\n self.private_call_stack.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n\n item.public_inputs.return_values\n }\n\n pub fn call_public_function(\n &mut self,\n contract_address: Field, \n function_selector: Field, \n args: [Field; ARGS_COUNT]\n ) {\n let args_hash = hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n self.call_public_function_with_packed_args(contract_address, function_selector, args_hash)\n }\n\n pub fn call_public_function_no_args(\n &mut self,\n contract_address: Field, \n function_selector: Field,\n ) {\n self.call_public_function_with_packed_args(contract_address, function_selector, 0)\n }\n\n pub fn call_public_function_with_packed_args(\n &mut self,\n contract_address: Field,\n function_selector: Field,\n args_hash: Field\n ) {\n let fields = enqueue_public_function_call_internal(\n contract_address, \n function_selector, \n args_hash\n );\n let item = PublicCallStackItem {\n contract_address: fields[0],\n function_data: FunctionData {\n function_selector: fields[1],\n is_internal: fields[2] as bool,\n is_private: fields[3] as bool,\n is_constructor: fields[4] as bool,\n },\n public_inputs: PublicCircuitPublicInputs {\n call_context: CallContext {\n msg_sender : fields[5],\n storage_contract_address : fields[6],\n portal_contract_address : fields[7],\n function_selector: fields[8], // practically same as fields[1]\n is_delegate_call : fields[9] as bool,\n is_static_call : fields[10] as bool,\n is_contract_deployment: fields[11] as bool,\n\n start_side_effect_counter: fields[12],\n },\n args_hash: fields[13],\n return_values: [0; RETURN_VALUES_LENGTH],\n contract_storage_update_requests: [ContractStorageUpdateRequest::empty(); MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_CALL],\n contract_storage_read: [ContractStorageRead::empty(); MAX_PUBLIC_DATA_READS_PER_CALL],\n public_call_stack: [SideEffectWithRange::empty(); MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL],\n new_commitments: [SideEffect::empty(); MAX_NEW_COMMITMENTS_PER_CALL],\n new_nullifiers: [SideEffectLinkedToNoteHash::empty(); MAX_NEW_NULLIFIERS_PER_CALL],\n new_l2_to_l1_msgs:[SideEffect::empty(); MAX_NEW_L2_TO_L1_MSGS_PER_CALL],\n unencrypted_logs_hash:[0; NUM_FIELDS_PER_SHA256],\n unencrypted_log_preimages_length: 0,\n block_data: HistoricBlockData::empty(),\n prover_address: 0,\n },\n is_execution_request: true,\n };\n\n assert(contract_address == item.contract_address);\n assert(function_selector == item.function_data.function_selector);\n \n assert(args_hash == item.public_inputs.args_hash);\n\n // Assert that the call context of the enqueued call generated by the oracle matches our request.\n // We are issuing a regular call which is not delegate, static, or deployment. We also constrain\n // the msg_sender in the nested call to be equal to our address, and the execution context address\n // for the nested call to be equal to the address we actually called.\n assert(item.public_inputs.call_context.is_delegate_call == false);\n assert(item.public_inputs.call_context.is_static_call == false);\n assert(item.public_inputs.call_context.is_contract_deployment == false);\n assert(item.public_inputs.call_context.msg_sender == self.inputs.call_context.storage_contract_address);\n assert(item.public_inputs.call_context.storage_contract_address == contract_address);\n\n let side_effect = SideEffectWithRange {\n value: item.hash(),\n start_side_effect_counter: self.inputs.start_side_effect_counter,\n end_side_effect_counter: self.side_effect_counter,\n };\n self.public_call_stack.push(side_effect);\n }\n}\n\nuse crate::abi::{\n ContractStorageRead,\n ContractStorageUpdateRequest\n};\n\nstruct PublicContext {\n inputs: abi::PublicContextInputs,\n\n side_effect_counter: Field,\n\n args_hash : Field,\n return_values : BoundedVec,\n\n contract_storage_update_requests: BoundedVec,\n contract_storage_read: BoundedVec,\n public_call_stack: BoundedVec,\n\n new_commitments: BoundedVec,\n new_nullifiers: BoundedVec,\n\n new_l2_to_l1_msgs: BoundedVec,\n\n unencrypted_logs_hash: BoundedVec,\n unencrypted_logs_preimages_length: Field,\n\n block_data: HistoricBlockData,\n prover_address: Field,\n}\n\nimpl PublicContext {\n pub fn new(inputs: abi::PublicContextInputs, args_hash: Field) -> PublicContext {\n let empty_storage_read = ContractStorageRead::empty();\n let empty_storage_update = ContractStorageUpdateRequest::empty();\n PublicContext {\n inputs: inputs,\n\n side_effect_counter: 0, // incremented for every side effect in this context\n\n args_hash: args_hash,\n return_values: BoundedVec::new(0),\n\n contract_storage_update_requests: BoundedVec::new(empty_storage_update),\n contract_storage_read: BoundedVec::new(empty_storage_read),\n public_call_stack: BoundedVec::new(SideEffectWithRange::empty()),\n\n new_commitments: BoundedVec::new(SideEffect::empty()),\n new_nullifiers: BoundedVec::new(SideEffectLinkedToNoteHash::empty()),\n\n new_l2_to_l1_msgs: BoundedVec::new(SideEffect::empty()),\n\n unencrypted_logs_hash: BoundedVec::new(0),\n unencrypted_logs_preimages_length: 0,\n\n block_data: inputs.block_data,\n prover_address: 0,\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n // encrypted_logs_preimages: Vec::new(),\n // unencrypted_logs_preimages: Vec::new(),\n }\n }\n\n pub fn msg_sender(self) -> Field {\n self.inputs.call_context.msg_sender\n }\n\n pub fn this_address(self) -> Field {\n self.inputs.call_context.storage_contract_address\n }\n\n pub fn this_portal_address(self) -> Field {\n self.inputs.call_context.portal_contract_address\n }\n\n pub fn chain_id(self) -> Field {\n self.inputs.public_global_variables.chain_id\n }\n\n pub fn version(self) -> Field {\n self.inputs.public_global_variables.version\n }\n\n pub fn selector(self) -> Field {\n self.inputs.call_context.function_selector\n }\n\n pub fn block_number(self) -> Field {\n self.inputs.public_global_variables.block_number\n }\n\n pub fn timestamp(self) -> Field {\n self.inputs.public_global_variables.timestamp\n }\n\n pub fn finish(self) -> abi::PublicCircuitPublicInputs {\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n let unencrypted_logs_hash = [0; NUM_FIELDS_PER_SHA256];\n let unencrypted_log_preimages_length = 0;\n\n\n // Compute the public call stack hashes\n // TODO(dbanks12): is this actually computing any public call stack hashes as comment says?\n let pub_circuit_pub_inputs = abi::PublicCircuitPublicInputs {\n call_context: self.inputs.call_context, // Done\n args_hash: self.args_hash, // Done\n contract_storage_update_requests: self.contract_storage_update_requests.storage,\n contract_storage_read: self.contract_storage_read.storage,\n return_values: self.return_values.storage,\n new_commitments: self.new_commitments.storage,\n new_nullifiers: self.new_nullifiers.storage,\n public_call_stack: self.public_call_stack.storage,\n new_l2_to_l1_msgs: self.new_l2_to_l1_msgs.storage,\n unencrypted_logs_hash: unencrypted_logs_hash,\n unencrypted_log_preimages_length: unencrypted_log_preimages_length,\n block_data: self.inputs.block_data,\n prover_address: self.prover_address,\n };\n pub_circuit_pub_inputs\n }\n\n pub fn push_new_note_hash(&mut self, note_hash: Field) {\n let side_effect = SideEffect {\n value: note_hash,\n side_effect_counter: self.side_effect_counter\n };\n self.new_commitments.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n pub fn push_new_nullifier(&mut self, nullifier: Field, _nullified_commitment: Field) {\n let side_effect = SideEffectLinkedToNoteHash {\n value: nullifier,\n note_hash: EMPTY_NULLIFIED_COMMITMENT, // cannot nullify pending notes in public context\n side_effect_counter: self.side_effect_counter\n };\n self.new_nullifiers.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n pub fn message_portal(&mut self, content: Field) {\n let side_effect = SideEffect {\n value: content,\n side_effect_counter: self.side_effect_counter\n };\n self.new_l2_to_l1_msgs.push(side_effect);\n self.side_effect_counter = self.side_effect_counter + 1;\n }\n\n // PrivateContextInputs must be temporarily passed in to prevent too many unknowns\n // Note this returns self to get around an issue where mutable structs do not maintain mutations unless reassigned\n pub fn consume_l1_to_l2_message(&mut self, msg_key: Field, content: Field, secret: Field) {\n let this = (*self).this_address();\n let nullifier = process_l1_to_l2_message(self.block_data.l1_to_l2_messages_tree_root, this, msg_key, content, secret);\n\n // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n self.push_new_nullifier(nullifier, EMPTY_NULLIFIED_COMMITMENT)\n }\n\n pub fn accumulate_encrypted_logs(&mut self, log: [Field; N]) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn accumulate_unencrypted_logs(&mut self, log: T) {\n let _void1 = self;\n let _void2 = log;\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165)\n }\n\n pub fn call_public_function(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n args: [Field; ARGS_COUNT],\n ) -> [Field; RETURN_VALUES_LENGTH] {\n let args_hash = abi::hash_args(args);\n assert(args_hash == arguments::pack_arguments(args));\n call_public_function_internal(\n contract_address, \n function_selector, \n args_hash,\n )\n }\n\n pub fn call_public_function_no_args(\n _self: Self,\n contract_address: Field, \n function_selector: Field,\n ) -> [Field; RETURN_VALUES_LENGTH] {\n call_public_function_internal(\n contract_address, \n function_selector, \n 0,\n )\n }\n\n}\n\nstruct Context {\n private: Option<&mut PrivateContext>,\n public: Option<&mut PublicContext>,\n}\n\nimpl Context {\n pub fn private(context: &mut PrivateContext) -> Context {\n Context {\n private: Option::some(context),\n public: Option::none()\n }\n }\n\n pub fn public(context: &mut PublicContext) -> Context {\n Context {\n public: Option::some(context),\n private: Option::none()\n }\n }\n\n pub fn none() -> Context {\n Context {\n public: Option::none(),\n private: Option::none()\n }\n }\n}", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/context" }, "40": { "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::oracle;\nuse crate::types::point::Point;\n\npub fn emit_encrypted_log(\n context: &mut PrivateContext,\n contract_address: Field,\n storage_slot: Field,\n encryption_pub_key: Point,\n log: [Field; N],\n) {\n let _ = oracle::logs::emit_encrypted_log(contract_address, storage_slot, encryption_pub_key, log);\n context.accumulate_encrypted_logs(log);\n}\n\npub fn emit_unencrypted_log(\n context: &mut PublicContext,\n log: T,\n) {\n let contract_address = context.this_address();\n let event_selector = 5; // TODO: compute actual event selector.\n let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n // context.accumulate_unencrypted_logs(log);\n}\n\n// TODO: We might want to remove this since emitting unencrypted logs from private functions is violating privacy.\n// --> might be a better approach to force devs to make a public function call that emits the log if needed then\n// it would be less easy to accidentally leak information.\n// If we decide to keep this function around would make sense to wait for traits and then merge it with emit_unencrypted_log.\npub fn emit_unencrypted_log_from_private(\n context: &mut PrivateContext,\n log: T,\n) {\n let contract_address = context.this_address();\n let event_selector = 5; // TODO: compute actual event selector.\n let _ = oracle::logs::emit_unencrypted_log(contract_address, event_selector, log);\n // context.accumulate_unencrypted_logs(log);\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/log" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/log" }, "45": { "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::context::{\n PrivateContext,\n PublicContext,\n};\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_inner_note_hash,\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\nuse crate::constants_gen::EMPTY_NULLIFIED_COMMITMENT;\n\npub fn create_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n let serialize = note_interface.serialize;\n let preimage = serialize(*note);\n assert(notify_created_note(storage_slot, preimage, inner_note_hash) == 0);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\npub fn create_note_hash_from_public(\n context: &mut PublicContext,\n storage_slot: Field,\n note: &mut Note,\n note_interface: NoteInterface,\n) {\n let contract_address = (*context).this_address();\n\n let header = NoteHeader { contract_address, storage_slot, nonce: 0, is_transient: true };\n let set_header = note_interface.set_header;\n set_header(note, header);\n let inner_note_hash = compute_inner_note_hash(note_interface, *note);\n\n context.push_new_note_hash(inner_note_hash);\n}\n\npub fn destroy_note(\n context: &mut PrivateContext,\n note: Note,\n note_interface: NoteInterface,\n) {\n let mut nullifier = 0;\n let mut nullified_commitment: Field = EMPTY_NULLIFIED_COMMITMENT;\n let compute_nullifier = note_interface.compute_nullifier;\n nullifier = compute_nullifier(note);\n\n // We also need the note commitment corresponding to the \"nullifier\"\n let get_header = note_interface.get_header;\n let header = get_header(note);\n // `nullified_commitment` is used to inform the kernel which pending commitment\n // the nullifier corresponds to so they can be matched and both squashed/deleted.\n // nonzero nonce implies \"persistable\" nullifier (nullifies a persistent/in-tree\n // commitment) in which case `nullified_commitment` is not used since the kernel\n // just siloes and forwards the nullier to its output.\n if (header.is_transient) {\n // TODO(1718): Can we reuse the note commitment computed in `compute_nullifier`?\n nullified_commitment = compute_inner_note_hash(note_interface, note);\n }\n assert(notify_nullified_note(nullifier, nullified_commitment) == 0);\n\n context.push_new_nullifier(nullifier, nullified_commitment)\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/lifecycle" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/note/lifecycle" }, "46": { "source": "use dep::std::option::Option;\nuse crate::constants_gen::{\n MAX_READ_REQUESTS_PER_CALL,\n GET_NOTE_ORACLE_RETURN_LENGTH,\n GET_NOTES_ORACLE_RETURN_LENGTH,\n MAX_NOTES_PER_PAGE,\n VIEW_NOTE_ORACLE_RETURN_LENGTH,\n};\nuse crate::context::PrivateContext;\nuse crate::note::{\n note_getter_options::{NoteGetterOptions, Select, Sort, SortOrder},\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\nuse crate::oracle;\nuse crate::types::vec::BoundedVec;\n\nfn check_note_header(\n context: PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n note: Note,\n) {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n let contract_address = context.this_address();\n assert(header.contract_address == contract_address);\n assert(header.storage_slot == storage_slot);\n}\n\nfn check_note_fields(\n fields: [Field; N],\n selects: BoundedVec, N>,\n) {\n for i in 0..selects.len {\n let select = selects.get_unchecked(i).unwrap_unchecked();\n assert(fields[select.field_index] == select.value, \"Mismatch return note field.\");\n }\n}\n\nfn check_notes_order(fields_0: [Field; N], fields_1: [Field; N], sorts: BoundedVec, N>) {\n for i in 0..sorts.len {\n let sort = sorts.get_unchecked(i).unwrap_unchecked();\n let eq = fields_0[sort.field_index] == fields_1[sort.field_index];\n let lt = fields_0[sort.field_index] as u120 < fields_1[sort.field_index] as u120;\n if sort.order == SortOrder.ASC {\n assert(eq | lt, \"Return notes not sorted in ascending order.\");\n } else if !eq {\n assert(!lt, \"Return notes not sorted in descending order.\");\n }\n }\n}\n\npub fn get_note(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let note = get_note_internal(storage_slot, note_interface);\n\n check_note_header(*context, storage_slot, note_interface, note);\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n\n context.push_read_request(note_hash_for_read_request);\n note\n}\n\npub fn get_notes(\n context: &mut PrivateContext,\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let opt_notes = get_notes_internal(storage_slot, note_interface, options);\n let mut num_notes = 0;\n let mut prev_fields = [0; N];\n for i in 0..opt_notes.len() {\n let opt_note = opt_notes[i];\n if opt_note.is_some() {\n let note = opt_note.unwrap_unchecked();\n let serialize = note_interface.serialize;\n let fields = serialize(note);\n check_note_header(*context, storage_slot, note_interface, note);\n check_note_fields(fields, options.selects);\n if i != 0 {\n check_notes_order(prev_fields, fields, options.sorts);\n }\n prev_fields = fields;\n\n let note_hash_for_read_request = compute_note_hash_for_read_or_nullify(note_interface, note);\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n context.push_read_request(note_hash_for_read_request);\n\n num_notes += 1;\n };\n };\n if options.limit != 0 {\n assert(num_notes <= options.limit, \"Invalid number of return notes.\");\n }\n opt_notes\n}\n\nunconstrained fn get_note_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n) -> Note {\n let placeholder_note = [Option::none()];\n let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n 0,\n [],\n [],\n [],\n [],\n 1, // limit\n 0, // offset\n placeholder_note,\n placeholder_fields,\n )[0].unwrap() // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteGetterOptions,\n) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n let opt_notes = oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n );\n\n let filter = options.filter;\n let filter_args = options.filter_args;\n filter(opt_notes, filter_args)\n}\n\nunconstrained pub fn view_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n options: NoteViewerOptions,\n) -> [Option; MAX_NOTES_PER_PAGE] {\n let (num_selects, select_by, select_values, sort_by, sort_order) = flatten_options(options.selects, options.sorts);\n let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n oracle::notes::get_notes(\n storage_slot,\n note_interface,\n num_selects,\n select_by,\n select_values,\n sort_by,\n sort_order,\n options.limit,\n options.offset,\n placeholder_opt_notes,\n placeholder_fields,\n )\n}\n\nunconstrained fn flatten_options(\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n) -> (u8, [u8; N], [Field; N], [u8; N], [u2; N]) {\n let mut num_selects = 0;\n let mut select_by = [0; N];\n let mut select_values = [0; N];\n for i in 0..selects.len {\n let select = selects.get(i);\n if select.is_some() {\n select_by[num_selects] = select.unwrap_unchecked().field_index;\n select_values[num_selects] = select.unwrap_unchecked().value;\n num_selects += 1;\n };\n };\n\n let mut sort_by = [0; N];\n let mut sort_order = [0; N];\n for i in 0..sorts.len {\n let sort = sorts.get(i);\n if sort.is_some() {\n sort_by[i] = sort.unwrap_unchecked().field_index;\n sort_order[i] = sort.unwrap_unchecked().order;\n };\n };\n\n (num_selects, select_by, select_values, sort_by, sort_order)\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_getter" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/note/note_getter" }, "48": { "source": "use dep::std::hash::{pedersen, pedersen_with_separator};\nuse crate::constants_gen::{GENERATOR_INDEX__UNIQUE_COMMITMENT, GENERATOR_INDEX__SILOED_COMMITMENT};\n\npub fn compute_inner_hash(storage_slot: Field, note_hash: Field) -> Field {\n // TODO(#1205) Do we need a generator index here?\n pedersen([storage_slot, note_hash])[0]\n}\n\npub fn compute_siloed_hash(contract_address: Field, inner_note_hash: Field) -> Field {\n let inputs = [contract_address, inner_note_hash];\n pedersen_with_separator(inputs, GENERATOR_INDEX__SILOED_COMMITMENT)[0]\n}\n\npub fn compute_unique_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n pedersen_with_separator(inputs, GENERATOR_INDEX__UNIQUE_COMMITMENT)[0]\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_hash" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/note/note_hash" }, "51": { "source": "use dep::std::option::Option;\nuse crate::constants_gen::MAX_NOTES_PER_PAGE;\nuse crate::note::note_getter_options::{Select, Sort};\nuse crate::types::vec::BoundedVec;\n\n// docs:start:NoteViewerOptions\nstruct NoteViewerOptions {\n selects: BoundedVec, N>,\n sorts: BoundedVec, N>,\n limit: u32,\n offset: u32,\n}\n// docs:end:NoteViewerOptions\n\nimpl NoteViewerOptions {\n pub fn new() -> NoteViewerOptions {\n NoteViewerOptions {\n selects: BoundedVec::new(Option::none()),\n sorts: BoundedVec::new(Option::none()),\n limit: MAX_NOTES_PER_PAGE as u32,\n offset: 0,\n }\n }\n\n pub fn select(&mut self, field_index: u8, value: Field) -> Self {\n self.selects.push(Option::some(Select::new(field_index, value)));\n *self\n }\n\n pub fn sort(&mut self, field_index: u8, order: u2) -> Self {\n self.sorts.push(Option::some(Sort::new(field_index, order)));\n *self\n }\n\n pub fn set_limit(&mut self, limit: u32) -> Self {\n assert(limit <= MAX_NOTES_PER_PAGE as u32);\n self.limit = limit;\n *self\n }\n\n pub fn set_offset(&mut self, offset: u32) -> Self {\n self.offset = offset;\n *self\n }\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/note_viewer_options" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/note/note_viewer_options" }, "52": { "source": "use crate::note::{\n note_hash::{compute_inner_hash, compute_siloed_hash, compute_unique_hash},\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\npub fn compute_inner_note_hash(\n note_interface: NoteInterface,\n note: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n\n compute_inner_hash(header.storage_slot, note_hash)\n}\n\npub fn compute_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let inner_note_hash = compute_inner_note_hash(note_interface, note_with_header);\n\n compute_siloed_hash(header.contract_address, inner_note_hash)\n}\n\npub fn compute_unique_siloed_note_hash(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n let siloed_note_hash = compute_siloed_note_hash(note_interface, note_with_header);\n\n compute_unique_hash(header.nonce, siloed_note_hash)\n}\n\npub fn compute_note_hash_for_read_or_nullify(\n note_interface: NoteInterface,\n note_with_header: Note,\n) -> Field {\n let get_header = note_interface.get_header;\n let header = get_header(note_with_header);\n\n // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1386)\n if (header.is_transient) {\n // If a note is transient, we just read the inner_note_hash (kernel will silo by contract address).\n compute_inner_note_hash(note_interface, note_with_header)\n } else if (header.nonce == 0) {\n // If not transient and nonce is zero, that means we are reading a public note.\n compute_siloed_note_hash(note_interface, note_with_header)\n } else {\n // When nonce is nonzero, that means we are reading a settled note (from tree) created in a\n // previous TX. So we need the unique_siloed_note_hash which has already been hashed with\n // contract address and then nonce. This hash will match the existing leaf in the private\n // data tree, so the kernel can just perform a membership check directly on this hash/leaf.\n compute_unique_siloed_note_hash(note_interface, note_with_header)\n }\n\n}\n\npub fn compute_note_hash_and_nullifier(\n note_interface: NoteInterface,\n note_header: NoteHeader,\n preimage: [Field; S],\n) -> [Field; 4] {\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n let mut note = deserialize(arr_copy_slice(preimage, [0; N], 0));\n set_header(&mut note, note_header);\n\n let compute_note_hash = note_interface.compute_note_hash;\n let note_hash = compute_note_hash(note);\n let inner_note_hash = compute_inner_hash(note_header.storage_slot, note_hash);\n\n let siloed_note_hash = compute_siloed_hash(note_header.contract_address, inner_note_hash);\n\n let unique_siloed_note_hash = compute_unique_hash(note_header.nonce, siloed_note_hash);\n\n let compute_nullifier = note_interface.compute_nullifier;\n let inner_nullifier = compute_nullifier(note);\n\n [inner_note_hash, siloed_note_hash, unique_siloed_note_hash, inner_nullifier]\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/note/utils" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/note/utils" }, "59": { "source": "use crate::types::point::Point;\nuse crate::address::compute_address;\n\n#[oracle(getPublicKey)]\nfn get_public_key_oracle(_address: Field) -> [Field; 3] {}\n\nunconstrained fn get_public_key_internal(address: Field) -> [Field; 3] {\n get_public_key_oracle(address)\n}\n\npub fn get_public_key(address: Field) -> Point {\n let result = get_public_key_internal(address);\n let pub_key_x = result[0];\n let pub_key_y = result[1];\n let partial_address = result[2];\n \n let calculated_address = compute_address(pub_key_x, pub_key_y, partial_address);\n assert(calculated_address == address);\n \n Point::new(pub_key_x, pub_key_y)\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/get_public_key" }, "60": { "source": "use crate::oracle::get_public_key::get_public_key;\nuse crate::types::point::Point;\n\n#[oracle(getSecretKey)]\nfn get_secret_key_oracle(\n _owner: Point,\n) -> [Field; dep::std::grumpkin_scalar::GRUMPKIN_SCALAR_SERIALIZED_LEN] {\n}\n\nunconstrained fn get_secret_key_internal(owner_public_key: Point) -> dep::std::grumpkin_scalar::GrumpkinScalar {\n dep::std::grumpkin_scalar::deserialize_grumpkin_scalar(get_secret_key_oracle(owner_public_key))\n}\n\npub fn get_secret_key(owner: Field) -> dep::std::grumpkin_scalar::GrumpkinScalar {\n let owner_public_key = get_public_key(owner);\n let secret = get_secret_key_internal(owner_public_key);\n\n // Constrain the owner - Nullifier secret key is currently just the encryption private key so we can constrain\n // the owner by deriving the public key from the secret key and checking the result.\n let computed_public_key = dep::std::grumpkin_scalar_mul::grumpkin_fixed_base(secret);\n assert(owner_public_key.x == computed_public_key[0]);\n assert(owner_public_key.y == computed_public_key[1]);\n\n secret\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/get_secret_key" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/get_secret_key" }, "61": { "source": "\n\n#[oracle(getRandomField)]\nfn rand_oracle() -> Field {}\n\nunconstrained pub fn rand() -> Field {\n rand_oracle()\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/rand" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/rand" }, "64": { "source": "use dep::std::option::Option;\nuse crate::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n};\nuse crate::utils::arr_copy_slice;\n\n#[oracle(notifyCreatedNote)]\nfn notify_created_note_oracle(\n _storage_slot: Field,\n _preimage: [Field; N],\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained pub fn notify_created_note(\n storage_slot: Field,\n preimage: [Field; N],\n inner_note_hash: Field,\n) -> Field {\n notify_created_note_oracle(storage_slot, preimage, inner_note_hash)\n}\n\n#[oracle(notifyNullifiedNote)]\nfn notify_nullified_note_oracle(\n _nullifier: Field,\n _inner_note_hash: Field,\n) -> Field {}\n\nunconstrained pub fn notify_nullified_note(\n nullifier: Field,\n inner_note_hash: Field,\n) -> Field {\n notify_nullified_note_oracle(nullifier, inner_note_hash)\n}\n\n#[oracle(getNotes)]\nfn get_notes_oracle(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by: [u8; N],\n _select_values: [Field; N],\n _sort_by: [u8; N],\n _sort_order: [u2; N],\n _limit: u32,\n _offset: u32,\n _return_size: u32,\n _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper(\n storage_slot: Field,\n num_selects: u8,\n select_by: [u8; N],\n select_values: [Field; N],\n sort_by: [u8; N],\n sort_order: [u2; N],\n limit: u32,\n offset: u32,\n mut placeholder_fields: [Field; S],\n)-> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\n get_notes_oracle(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, return_size, placeholder_fields)\n}\n\nunconstrained pub fn get_notes(\n storage_slot: Field,\n note_interface: NoteInterface,\n num_selects: u8,\n select_by: [u8; M],\n select_values: [Field; M],\n sort_by: [u8; M],\n sort_order: [u2; M],\n limit: u32,\n offset: u32,\n mut placeholder_opt_notes: [Option; S], // TODO: Remove it and use `limit` to initialize the note array.\n placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n) -> [Option; S] {\n let fields = get_notes_oracle_wrapper(storage_slot, num_selects, select_by, select_values, sort_by, sort_order, limit, offset, placeholder_fields);\n let num_notes = fields[0] as u32;\n let contract_address = fields[1];\n let deserialize = note_interface.deserialize;\n let set_header = note_interface.set_header;\n for i in 0..placeholder_opt_notes.len() {\n if i as u32 < num_notes {\n // lengths named as per typescript.\n let return_header_length: Field = 2; // num_notes & contract_address.\n let extra_preimage_length: Field = 2; // nonce & is_transient.\n let read_offset: Field = return_header_length + i * (N + extra_preimage_length);\n let nonce = fields[read_offset];\n let is_transient = fields[read_offset + 1] as bool;\n let header = NoteHeader { contract_address, nonce, storage_slot, is_transient };\n let preimage = arr_copy_slice(fields, [0; N], read_offset + 2);\n let mut note = deserialize(preimage);\n set_header(&mut note, header);\n placeholder_opt_notes[i] = Option::some(note);\n };\n };\n placeholder_opt_notes\n}\n\n#[oracle(checkNullifierExists)]\nfn check_nullifier_exists_oracle(\n _inner_nullifier: Field,\n) -> Field {}\n\nunconstrained pub fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier) == 1\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/notes" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/notes" }, "66": { "source": "use crate::types::point::Point;\nuse crate::constants_gen::NUM_FIELDS_PER_SHA256;\n\n// TODO: Should take encrypted data.\n#[oracle(emitEncryptedLog)]\nfn emit_encrypted_log_oracle(\n _contract_address: Field,\n _storage_slot: Field,\n _encryption_pub_key: Point,\n _preimage: [Field; N],\n) -> Field {}\n\nunconstrained pub fn emit_encrypted_log(\n contract_address: Field,\n storage_slot: Field,\n encryption_pub_key: Point,\n preimage: [Field; N],\n) -> [Field; NUM_FIELDS_PER_SHA256] {\n [emit_encrypted_log_oracle(\n contract_address,\n storage_slot,\n encryption_pub_key,\n preimage,\n ), 0]\n}\n\n#[oracle(emitUnencryptedLog)]\nfn emit_unencrypted_log_oracle(_contract_address: Field, _event_selector: Field, _message: T) -> Field {}\n\nunconstrained pub fn emit_unencrypted_log(contract_address: Field, event_selector: Field, message: T) -> [Field; NUM_FIELDS_PER_SHA256] {\n // https://github.com/AztecProtocol/aztec-packages/issues/885\n [emit_unencrypted_log_oracle(contract_address, event_selector, message), 0]\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/oracle/logs" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/oracle/logs" }, "72": { "source": "use crate::context::{PrivateContext, PublicContext, Context};\nuse dep::std::option::Option;\n\n// docs:start:map\nstruct Map {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl Map {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Map {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map {\n context,\n storage_slot,\n state_var_constructor,\n }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: Field) -> V {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = dep::std::hash::pedersen([self.storage_slot, key])[0];\n\n let state_var_constructor = self.state_var_constructor;\n state_var_constructor(self.context, derived_storage_slot)\n }\n // docs:end:at\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/state_vars/map" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/state_vars/map" }, "74": { - "source": "use dep::std::option::Option;\nuse crate::abi::PublicContextInputs;\nuse crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_header::NoteHeader,\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\n\n// docs:start:struct\nstruct Set {\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n// docs:end:struct\n\nimpl Set {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Set {\n context,\n storage_slot,\n note_interface,\n }\n }\n // docs:end:new\n\n // docs:start:insert\n pub fn insert(self, note: &mut Note) {\n create_note(\n self.context.private.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert\n\n // docs:start:insert_from_public\n pub fn insert_from_public(self, note: &mut Note) {\n create_note_hash_from_public(\n self.context.public.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert_from_public\n \n // DEPRECATED\n fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) {\n assert(false, \"`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // DEPRECATED\n fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) {\n assert(false, \"`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // docs:start:remove\n pub fn remove(self, note: Note) {\n let context = self.context.private.unwrap();\n let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n let has_been_read = context.read_requests.any(|r| r == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note(\n context,\n note,\n self.note_interface,\n );\n }\n // docs:end:remove\n\n // docs:start:get_notes\n pub fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let storage_slot = self.storage_slot;\n let opt_notes = get_notes(\n self.context.private.unwrap(),\n storage_slot,\n self.note_interface,\n options,\n );\n opt_notes\n }\n // docs:end:get_notes\n\n // docs:start:view_notes\n unconstrained pub fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> [Option; MAX_NOTES_PER_PAGE] {\n view_notes(self.storage_slot, self.note_interface, options)\n }\n // docs:end:view_notes\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/state_vars/set" + "source": "use dep::std::option::Option;\nuse crate::abi::{\n PublicContextInputs,\n SideEffect,\n};\nuse crate::constants_gen::{MAX_NOTES_PER_PAGE, MAX_READ_REQUESTS_PER_CALL};\nuse crate::context::{PrivateContext, PublicContext, Context};\nuse crate::note::{\n lifecycle::{create_note, create_note_hash_from_public, destroy_note},\n note_getter::{get_notes, view_notes},\n note_getter_options::NoteGetterOptions,\n note_header::NoteHeader,\n note_interface::NoteInterface,\n note_viewer_options::NoteViewerOptions,\n utils::compute_note_hash_for_read_or_nullify,\n};\n\n// docs:start:struct\nstruct Set {\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n}\n// docs:end:struct\n\nimpl Set {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n note_interface: NoteInterface,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Set {\n context,\n storage_slot,\n note_interface,\n }\n }\n // docs:end:new\n\n // docs:start:insert\n pub fn insert(self, note: &mut Note) {\n create_note(\n self.context.private.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert\n\n // docs:start:insert_from_public\n pub fn insert_from_public(self, note: &mut Note) {\n create_note_hash_from_public(\n self.context.public.unwrap(),\n self.storage_slot,\n note,\n self.note_interface,\n );\n }\n // docs:end:insert_from_public\n \n // DEPRECATED\n fn assert_contains_and_remove(_self: Self, _note: &mut Note, _nonce: Field) {\n assert(false, \"`assert_contains_and_remove` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // DEPRECATED\n fn assert_contains_and_remove_publicly_created(_self: Self, _note: &mut Note) {\n assert(false, \"`assert_contains_and_remove_publicly_created` has been deprecated. Please call PXE.addNote() to add a note to the database. Then use Set.get_notes() and Set.remove() in your contract to verify and remove a note.\");\n }\n\n // docs:start:remove\n pub fn remove(self, note: Note) {\n let context = self.context.private.unwrap();\n let note_hash = compute_note_hash_for_read_or_nullify(self.note_interface, note);\n let has_been_read = context.read_requests.any(|r: SideEffect| r.value == note_hash);\n assert(has_been_read, \"Can only remove a note that has been read from the set.\");\n\n destroy_note(\n context,\n note,\n self.note_interface,\n );\n }\n // docs:end:remove\n\n // docs:start:get_notes\n pub fn get_notes(\n self,\n options: NoteGetterOptions,\n ) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let storage_slot = self.storage_slot;\n let opt_notes = get_notes(\n self.context.private.unwrap(),\n storage_slot,\n self.note_interface,\n options,\n );\n opt_notes\n }\n // docs:end:get_notes\n\n // docs:start:view_notes\n unconstrained pub fn view_notes(\n self,\n options: NoteViewerOptions,\n ) -> [Option; MAX_NOTES_PER_PAGE] {\n view_notes(self.storage_slot, self.note_interface, options)\n }\n // docs:end:view_notes\n}\n", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/state_vars/set" }, "79": { - "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\n pub fn new(initial_value: T) -> Self {\n BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n }\n\n pub fn get(mut self: Self, index: Field) -> T {\n assert(index as u64 < self.len as u64);\n self.storage[index]\n }\n\n pub fn get_unchecked(mut self: Self, index: Field) -> T {\n self.storage[index]\n }\n\n pub fn push(&mut self, elem: T) {\n assert(self.len as u64 < MaxLen as u64);\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n pub fn push_array(&mut self, array: [T; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = newLen;\n }\n\n pub fn pop(&mut self) -> T {\n assert(self.len as u64 > 0);\n\n let elem = self.storage[self.len - 1];\n self.len -= 1;\n elem\n }\n\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if (!exceeded_len) {\n ret |= predicate(self.storage[i]);\n }\n }\n ret\n }\n}\n\n#[test]\nfn test_vec_push_pop() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n assert(vec.len == 0);\n vec.push(2);\n assert(vec.len == 1);\n vec.push(4);\n assert(vec.len == 2);\n vec.push(6);\n assert(vec.len == 3);\n let x = vec.pop();\n assert(x == 6);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2]);\n let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialized() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push(1);\n vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4, 6]);\n assert(vec.any(|v| v == 2) == true);\n assert(vec.any(|v| v == 4) == true);\n assert(vec.any(|v| v == 6) == true);\n assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n let default_value = 1;\n let mut vec: BoundedVec = BoundedVec::new(default_value);\n vec.push_array([2, 4]);\n assert(vec.any(|v| v == default_value) == false);\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/types/vec" + "source": "\nstruct BoundedVec {\n storage: [T; MaxLen],\n len: Field,\n}\n\nimpl BoundedVec {\n pub fn new(initial_value: T) -> Self {\n BoundedVec { storage: [initial_value; MaxLen], len: 0 }\n }\n\n pub fn get(mut self: Self, index: Field) -> T {\n assert(index as u64 < self.len as u64);\n self.storage[index]\n }\n\n pub fn get_unchecked(mut self: Self, index: Field) -> T {\n self.storage[index]\n }\n\n pub fn push(&mut self, elem: T) {\n assert(self.len as u64 < MaxLen as u64);\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n pub fn push_array(&mut self, array: [T; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = newLen;\n }\n\n pub fn pop(&mut self) -> T {\n assert(self.len as u64 > 0);\n\n let elem = self.storage[self.len - 1];\n self.len -= 1;\n elem\n }\n\n pub fn any(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n let mut exceeded_len = false;\n for i in 0..MaxLen {\n exceeded_len |= i == self.len;\n if (!exceeded_len) {\n ret |= predicate(self.storage[i]);\n }\n }\n ret\n }\n\n fn flatten_and_push_array(&mut self, serialize: fn(S) -> [T; InnerLen], array: [S; Len]) {\n let newLen = self.len + (array.len() * InnerLen);\n assert(newLen as u64 <= MaxLen as u64);\n for outer in 0..array.len() {\n let inner_array = serialize(array[outer]);\n self.push_array(inner_array);\n // TODO: more efficient:\n //for inner in 0..inner_array.len() {\n // self.storage[self.len + (outer * InnerLen) + inner] = inner_array[inner];\n //}\n }\n }\n\n fn map_and_push_array(&mut self, func: fn(S) -> T, array: [S; Len]) {\n let newLen = self.len + array.len();\n assert(newLen as u64 <= MaxLen as u64);\n for idx in 0..array.len() {\n self.push(func(array[idx]));\n }\n }\n\n}\n\n#[test]\nfn test_vec_push_pop() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n assert(vec.len == 0);\n vec.push(2);\n assert(vec.len == 1);\n vec.push(4);\n assert(vec.len == 2);\n vec.push(6);\n assert(vec.len == 3);\n let x = vec.pop();\n assert(x == 6);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test]\nfn test_vec_push_array() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n assert(vec.len == 2);\n assert(vec.get(0) == 2);\n assert(vec.get(1) == 4);\n}\n\n#[test(should_fail)]\nfn test_vec_get_out_of_bound() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4]);\n let _x = vec.get(2);\n}\n\n#[test(should_fail)]\nfn test_vec_get_not_declared() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2]);\n let _x = vec.get(1);\n}\n\n#[test(should_fail)]\nfn test_vec_get_uninitialized() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n let _x = vec.get(0);\n}\n\n#[test(should_fail)]\nfn test_vec_push_overflow() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push(1);\n vec.push(2);\n}\n\n#[test]\nfn test_vec_any() {\n let mut vec: BoundedVec = BoundedVec::new(0);\n vec.push_array([2, 4, 6]);\n assert(vec.any(|v| v == 2) == true);\n assert(vec.any(|v| v == 4) == true);\n assert(vec.any(|v| v == 6) == true);\n assert(vec.any(|v| v == 3) == false);\n}\n\n#[test]\nfn test_vec_any_not_default() {\n let default_value = 1;\n let mut vec: BoundedVec = BoundedVec::new(default_value);\n vec.push_array([2, 4]);\n assert(vec.any(|v| v == default_value) == false);\n}", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/types/vec" }, "85": { - "source": "pub fn arr_copy_slice(\n src: [T; N],\n mut dst: [T; M],\n offset: Field,\n) -> [T; M] {\n for i in 0..dst.len() {\n dst[i] = src[i + offset];\n }\n dst\n}\n\npub fn field_from_bytes(bytes: [u8; N], big_endian: bool) -> Field {\n assert(bytes.len() as u32 < 32, \"field_from_bytes: N must be less than 32\");\n let mut as_field = 0;\n let mut offset = 1;\n for i in 0..N {\n let mut index = i;\n if big_endian {\n index = N - i - 1;\n }\n as_field += (bytes[index] as Field) * offset;\n offset *= 256;\n }\n\n as_field\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/aztec/src/utils" + "source": "pub fn arr_copy_slice(\n src: [T; N],\n mut dst: [T; M],\n offset: Field,\n) -> [T; M] {\n for i in 0..dst.len() {\n dst[i] = src[i + offset];\n }\n dst\n}\n\n// pub fn arr_copy_slice_in_struct_lol(\n// src: [Field; N],\n// mut dst: [U; M],\n// deserialise: fn([Field; K]) -> U,\n// offset: Field,\n// ) -> [U; M] {\n// for i in 0..dst.len() {\n// let mut serialised = [0; K];\n// for j in 0..K {\n// serialised[j] = src[offset + i * K + j];\n// }\n// dst[i] = deserialise(serialised);\n// }\n// dst\n// }\n\n\n// pub fn arr_copy_slice_in_struct(\n// src: [Field; N],\n// mut dst: [U; M],\n// deserialise: fn([Field; K]) -> U,\n// offset: Field,\n// ) -> [U; M] {\n// for i in 0..dst.len() {\n// let inner_array = arr_copy_slice(src, [0; K], offset + i * K);\n// dst[i] = deserialise(inner_array);\n// }\n// dst\n// }\n\n// TODO: Replace these with something smart.\npub fn arr_copy_slice_in_struct_dumb2(\n src: [T; N],\n mut dst: [U; M],\n deserialise: fn([T; 2]) -> U,\n offset: Field,\n) -> [U; M] {\n for i in 0..dst.len() {\n dst[i] = deserialise([src[offset + 2 * i], src[offset + 2 * i + 1]]);\n }\n dst\n}\n\npub fn arr_copy_slice_in_struct_dumb3(\n src: [T; N],\n mut dst: [U; M],\n deserialise: fn([T; 3]) -> U,\n offset: Field,\n) -> [U; M] {\n for i in 0..dst.len() {\n dst[i] = deserialise([src[offset + 2 * i], src[offset + 2 * i + 1], src[offset + 2 * i + 2]]);\n }\n dst\n}\n\npub fn field_from_bytes(bytes: [u8; N], big_endian: bool) -> Field {\n assert(bytes.len() as u32 < 32, \"field_from_bytes: N must be less than 32\");\n let mut as_field = 0;\n let mut offset = 1;\n for i in 0..N {\n let mut index = i;\n if big_endian {\n index = N - i - 1;\n }\n as_field += (bytes[index] as Field) * offset;\n offset *= 256;\n }\n\n as_field\n}", + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/aztec/src/utils" }, "86": { "source": "use dep::aztec::note::{\n note_getter::view_notes,\n note_viewer_options::NoteViewerOptions,\n};\nuse dep::aztec::state_vars::set::Set;\nuse crate::value_note::{VALUE_NOTE_LEN, ValueNote};\n\nunconstrained pub fn get_balance(set: Set) -> Field {\n get_balance_with_offset(set, 0)\n}\n\nunconstrained pub fn get_balance_with_offset(set: Set, offset: u32) -> Field {\n let mut balance = 0;\n // docs:start:view_notes\n let options = NoteViewerOptions::new().set_offset(offset);\n let opt_notes = set.view_notes(options);\n // docs:end:view_notes\n let len = opt_notes.len();\n for i in 0..len {\n if opt_notes[i].is_some() {\n balance += opt_notes[i].unwrap_unchecked().value;\n }\n }\n if (opt_notes[len - 1].is_some()) {\n balance += get_balance_with_offset(set, offset + opt_notes.len() as u32);\n }\n\n balance\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/balance_utils" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/value-note/src/balance_utils" }, "87": { "source": "use dep::std::option::Option;\nuse dep::aztec::constants_gen::MAX_READ_REQUESTS_PER_CALL;\nuse crate::value_note::ValueNote;\n\npub fn filter_notes_min_sum(notes: [Option; MAX_READ_REQUESTS_PER_CALL], min_sum: Field) -> [Option; MAX_READ_REQUESTS_PER_CALL] {\n let mut selected = [Option::none(); MAX_READ_REQUESTS_PER_CALL];\n let mut sum = 0;\n for i in 0..notes.len() {\n if notes[i].is_some() & (sum < min_sum as u120) {\n let note = notes[i].unwrap_unchecked();\n selected[i] = Option::some(note);\n sum += note.value as u120;\n }\n }\n selected\n}", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/filter" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/value-note/src/filter" }, "88": { "source": "use dep::std::option::Option;\nuse dep::aztec::context::PrivateContext;\n// docs:start:encrypted_import\n\nuse dep::aztec::log::emit_encrypted_log;\n\n// docs:end:encrypted_import\nuse dep::aztec::note::note_getter_options::{NoteGetterOptions, SortOrder};\nuse dep::aztec::oracle::get_public_key::get_public_key;\nuse dep::aztec::state_vars::set::Set;\nuse crate::{\n filter::filter_notes_min_sum,\n value_note::{ValueNote, VALUE_NOTE_LEN},\n};\n\n// Sort the note values (0th field) in descending order.\n// Pick the fewest notes whose sum is equal to or greater than `amount`.\npub fn create_note_getter_options_for_decreasing_balance(amount: Field) -> NoteGetterOptions {\n NoteGetterOptions::with_filter(filter_notes_min_sum, amount).sort(0, SortOrder.DESC)\n}\n\n// Creates a new note for the recipient.\n// Inserts it to the recipient's set of notes.\npub fn increment(\n balance: Set,\n amount: Field,\n recipient: Field,\n) {\n let mut note = ValueNote::new(amount, recipient);\n create_note(balance, recipient, &mut note);\n\n // It won't compile if Set.insert() is in an if statement :(\n // if amount as u120 > 0 {\n // create_note(balance, recipient, &mut note);\n // }\n}\n\n// Find some of the `owner`'s notes whose values add up to the `amount`.\n// Remove those notes.\n// If the value of the removed notes exceeds the requested `amount`, create a new note containing the excess value, so that exactly `amount` is removed.\n// Fail if the sum of the selected notes is less than the amount.\npub fn decrement(\n balance: Set,\n amount: Field,\n owner: Field,\n) {\n let sum = decrement_by_at_most(balance, amount, owner);\n assert(sum == amount, \"Balance too low\");\n}\n\n// Similar to `decrement`, except that it doesn't fail if the decremented amount is less than max_amount.\n// The motivation behind this function is that there is an upper-bound on the number of notes a function may\n// read and nullify. The requested decrementation `amount` might be spread across too many of the `owner`'s\n// notes to 'fit' within this upper-bound, so we might have to remove an amount less than `amount`. A common\n// pattern is to repeatedly call this function across many function calls, until enough notes have been nullified to\n// equal `amount`.\n//\n// It returns the decremented amount, which should be less than or equal to max_amount.\npub fn decrement_by_at_most(\n balance: Set,\n max_amount: Field,\n owner: Field,\n) -> Field {\n let options = create_note_getter_options_for_decreasing_balance(max_amount);\n let opt_notes = balance.get_notes(options);\n\n let mut decremented = 0;\n for i in 0..opt_notes.len() {\n if opt_notes[i].is_some() {\n decremented += destroy_note(balance, owner, opt_notes[i].unwrap_unchecked());\n }\n }\n\n // Add the change value back to the owner's balance.\n let mut change_value = 0;\n if decremented as u120 > max_amount as u120 {\n change_value = decremented - max_amount;\n decremented -= change_value;\n }\n increment(balance, change_value, owner);\n\n decremented\n}\n\npub fn create_note(\n balance: Set,\n owner: Field,\n note: &mut ValueNote,\n) {\n // Insert the new note to the owner's set of notes.\n balance.insert(note);\n\n // Remove this if statement if we can wrap this create_note function in an if statement.\n if note.value != 0 {\n // Emit the newly created encrypted note preimages via oracle calls.\n // docs:start:encrypted\n let context = balance.context.private.unwrap();\n let application_contract_address = (*context).this_address();\n let note_storage_slot = balance.storage_slot;\n let encryption_pub_key = get_public_key(owner);\n let encrypted_data = (*note).serialize();\n\n emit_encrypted_log(\n context,\n application_contract_address,\n note_storage_slot,\n encryption_pub_key,\n encrypted_data,\n );\n // docs:end:encrypted\n }\n}\n\n// Removes the note from the owner's set of notes.\n// Returns the value of the destroyed note.\npub fn destroy_note(\n balance: Set,\n owner: Field,\n note: ValueNote,\n) -> Field {\n // Ensure the note is actually owned by the owner (to prevent user from generating a valid proof while\n // spending someone else's notes).\n assert(note.owner == owner);\n\n balance.remove(note);\n \n note.value\n}\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/utils" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/value-note/src/utils" }, "89": { "source": "use dep::aztec::note::{\n note_header::NoteHeader,\n note_interface::NoteInterface,\n utils::compute_note_hash_for_read_or_nullify,\n};\nuse dep::aztec::oracle::{\n rand::rand,\n get_secret_key::get_secret_key,\n};\n\nglobal VALUE_NOTE_LEN: Field = 3; // 3 plus a header.\n\n// docs:start:value-note-def\nstruct ValueNote {\n value: Field,\n owner: Field,\n randomness: Field,\n header: NoteHeader,\n}\n// docs:end:value-note-def\n\nimpl ValueNote {\n pub fn new(value: Field, owner: Field) -> Self {\n let randomness = rand();\n let header = NoteHeader::empty();\n ValueNote {\n value,\n owner,\n randomness,\n header,\n }\n }\n\n pub fn serialize(self) -> [Field; VALUE_NOTE_LEN] {\n [self.value, self.owner, self.randomness]\n }\n\n pub fn deserialize(preimage: [Field; VALUE_NOTE_LEN]) -> Self {\n ValueNote {\n value: preimage[0],\n owner: preimage[1],\n randomness: preimage[2],\n header: NoteHeader::empty(),\n }\n }\n\n pub fn compute_note_hash(self) -> Field {\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n self.value, \n self.owner,\n self.randomness,\n ])[0]\n }\n\n // docs:start:nullifier\n\n pub fn compute_nullifier(self) -> Field {\n let note_hash_for_nullify = compute_note_hash_for_read_or_nullify(ValueNoteMethods, self);\n let secret = get_secret_key(self.owner);\n // TODO(#1205) Should use a non-zero generator index.\n dep::std::hash::pedersen([\n note_hash_for_nullify,\n secret.low,\n secret.high,\n ])[0]\n }\n\n // docs:end:nullifier\n\n pub fn set_header(&mut self, header: NoteHeader) {\n self.header = header;\n }\n}\n\nfn deserialize(preimage: [Field; VALUE_NOTE_LEN]) -> ValueNote {\n ValueNote::deserialize(preimage)\n}\n\nfn serialize(note: ValueNote) -> [Field; VALUE_NOTE_LEN] {\n note.serialize()\n}\n\nfn compute_note_hash(note: ValueNote) -> Field {\n note.compute_note_hash()\n}\n\nfn compute_nullifier(note: ValueNote) -> Field {\n note.compute_nullifier()\n}\n\nfn get_header(note: ValueNote) -> NoteHeader {\n note.header\n}\n\nfn set_header(note: &mut ValueNote, header: NoteHeader) {\n note.set_header(header)\n}\n\nglobal ValueNoteMethods = NoteInterface {\n deserialize,\n serialize,\n compute_note_hash,\n compute_nullifier,\n get_header,\n set_header,\n};\n", - "path": "/Users/danlee/code/aztec-packages-2/yarn-project/aztec-nr/value-note/src/value_note" + "path": "/mnt/user-data/david/projects/3-aztec3/aztec-packages-hash/yarn-project/aztec-nr/value-note/src/value_note" } } } -} +} \ No newline at end of file diff --git a/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts index 1f4dcaabddde..cca2d3ae2855 100644 --- a/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts +++ b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts @@ -1,20 +1,8 @@ + /* Autogenerated file, do not edit! */ /* eslint-disable */ -import { - AztecAddress, - CompleteAddress, - Contract, - ContractBase, - ContractFunctionInteraction, - ContractMethod, - DeployMethod, - EthAddress, - FieldLike, - AztecAddressLike, - EthAddressLike, - Wallet, -} from '@aztec/aztec.js'; +import { AztecAddress, CompleteAddress, Contract, ContractBase, ContractFunctionInteraction, ContractMethod, DeployMethod, EthAddress, FieldLike, AztecAddressLike, EthAddressLike, Wallet } from '@aztec/aztec.js'; import { Fr, Point } from '@aztec/foundation/fields'; import { PXE, PublicKey } from '@aztec/types'; import { ContractArtifact } from '@aztec/foundation/abi'; @@ -25,61 +13,60 @@ export const PrivateTokenContractArtifact = PrivateTokenContractArtifactJson as * Type-safe interface for contract PrivateToken; */ export class PrivateTokenContract extends ContractBase { - private constructor(completeAddress: CompleteAddress, wallet: Wallet, portalContract = EthAddress.ZERO) { + + private constructor( + completeAddress: CompleteAddress, + wallet: Wallet, + portalContract = EthAddress.ZERO + ) { super(completeAddress, PrivateTokenContractArtifact, wallet, portalContract); } + + /** * Creates a contract instance. * @param address - The deployed contract's address. * @param wallet - The wallet to use when interacting with the contract. * @returns A promise that resolves to a new Contract instance. */ - public static async at(address: AztecAddress, wallet: Wallet) { + public static async at( + address: AztecAddress, + wallet: Wallet, + ) { return Contract.at(address, PrivateTokenContract.artifact, wallet) as Promise; } + /** * Creates a tx to deploy a new instance of this contract. */ public static deploy(pxe: PXE, initial_supply: FieldLike, owner: FieldLike) { - return new DeployMethod( - Point.ZERO, - pxe, - PrivateTokenContractArtifact, - Array.from(arguments).slice(1), - ); + return new DeployMethod(Point.ZERO, pxe, PrivateTokenContractArtifact, Array.from(arguments).slice(1)); } /** * Creates a tx to deploy a new instance of this contract using the specified public key to derive the address. */ public static deployWithPublicKey(pxe: PXE, publicKey: PublicKey, initial_supply: FieldLike, owner: FieldLike) { - return new DeployMethod( - publicKey, - pxe, - PrivateTokenContractArtifact, - Array.from(arguments).slice(2), - ); + return new DeployMethod(publicKey, pxe, PrivateTokenContractArtifact, Array.from(arguments).slice(2)); } + + /** * Returns this contract's artifact. */ public static get artifact(): ContractArtifact { return PrivateTokenContractArtifact; } + /** Type-safe wrappers for the public methods exposed by the contract. */ public methods!: { + /** compute_note_hash_and_nullifier(contract_address: field, nonce: field, storage_slot: field, preimage: array) */ - compute_note_hash_and_nullifier: (( - contract_address: FieldLike, - nonce: FieldLike, - storage_slot: FieldLike, - preimage: FieldLike[], - ) => ContractFunctionInteraction) & - Pick; + compute_note_hash_and_nullifier: ((contract_address: FieldLike, nonce: FieldLike, storage_slot: FieldLike, preimage: FieldLike[]) => ContractFunctionInteraction) & Pick; /** getBalance(owner: field) */ getBalance: ((owner: FieldLike) => ContractFunctionInteraction) & Pick; @@ -88,7 +75,6 @@ export class PrivateTokenContract extends ContractBase { mint: ((amount: FieldLike, owner: FieldLike) => ContractFunctionInteraction) & Pick; /** transfer(amount: field, recipient: field) */ - transfer: ((amount: FieldLike, recipient: FieldLike) => ContractFunctionInteraction) & - Pick; + transfer: ((amount: FieldLike, recipient: FieldLike) => ContractFunctionInteraction) & Pick; }; } From a5debcbc7219678064a430c200530b0fa73a6bfe Mon Sep 17 00:00:00 2001 From: dbanks12 Date: Fri, 13 Oct 2023 19:45:57 +0000 Subject: [PATCH 7/7] TS compiling --- .../acir-simulator/src/public/executor.ts | 3 +++ .../circuits.js/src/tests/factories.ts | 27 +++++++++++++++++++ .../src/integration_l1_publisher.test.ts | 11 ++++---- .../src/kernel_prover/kernel_prover.test.ts | 9 ++++--- .../pxe/src/kernel_prover/kernel_prover.ts | 16 ++++++----- .../pxe/src/kernel_prover/proof_creator.ts | 2 +- .../pxe/src/pxe_service/pxe_service.ts | 7 ++--- .../block_builder/solo_block_builder.test.ts | 26 ++++++++++-------- .../src/block_builder/solo_block_builder.ts | 8 +++--- .../src/sequencer/public_processor.test.ts | 20 ++++++++------ .../src/sequencer/public_processor.ts | 14 ++++++---- .../src/sequencer/sequencer.ts | 10 +++---- 12 files changed, 101 insertions(+), 52 deletions(-) diff --git a/yarn-project/acir-simulator/src/public/executor.ts b/yarn-project/acir-simulator/src/public/executor.ts index 557c5b0b3d2c..497661b3f4d9 100644 --- a/yarn-project/acir-simulator/src/public/executor.ts +++ b/yarn-project/acir-simulator/src/public/executor.ts @@ -39,6 +39,9 @@ export async function executePublicFunction( }, ); + // TODO(dbanks12): extract all things with side-effect counters (public call stack) + // as those counters must be passed to kernel + // Why only grab a few things from the circuit public inputs? const { returnValues, newL2ToL1Msgs, diff --git a/yarn-project/circuits.js/src/tests/factories.ts b/yarn-project/circuits.js/src/tests/factories.ts index deb37f7f7815..80569bf9e136 100644 --- a/yarn-project/circuits.js/src/tests/factories.ts +++ b/yarn-project/circuits.js/src/tests/factories.ts @@ -103,6 +103,33 @@ import { } from '../index.js'; import { GlobalVariables } from '../structs/global_variables.js'; +/** + * Creates an arbitrary side effect object with the given seed. + * @param seed - The seed to use for generating the object. + * @returns A side effect object. + */ +export function makeNewSideEffect(seed: number): SideEffect { + return new SideEffect(fr(seed), fr(seed + 1)); +} + +/** + * Creates an arbitrary side effect object (linked to a note hash) with the given seed. + * @param seed - The seed to use for generating the object. + * @returns A side effect object. + */ +export function makeNewSideEffectLinkedToNoteHash(seed: number): SideEffectLinkedToNoteHash { + return new SideEffectLinkedToNoteHash(fr(seed), fr(seed + 1), fr(seed + 2)); +} + +/** + * Creates an arbitrary side effect object (with counter range) with the given seed. + * @param seed - The seed to use for generating the object. + * @returns A side effect object. + */ +export function makeNewSideEffectWithRange(seed: number): SideEffectWithRange { + return new SideEffectWithRange(fr(seed), fr(seed + 1), fr(seed + 2)); +} + /** * Creates an arbitrary tx context with the given seed. * @param seed - The seed to use for generating the tx context. diff --git a/yarn-project/end-to-end/src/integration_l1_publisher.test.ts b/yarn-project/end-to-end/src/integration_l1_publisher.test.ts index 5875d3af99a3..e3029d21c351 100644 --- a/yarn-project/end-to-end/src/integration_l1_publisher.test.ts +++ b/yarn-project/end-to-end/src/integration_l1_publisher.test.ts @@ -9,10 +9,11 @@ import { MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PublicDataUpdateRequest, + SideEffectLinkedToNoteHash, makeTuple, range, } from '@aztec/circuits.js'; -import { fr, makeNewContractData, makeProof } from '@aztec/circuits.js/factories'; +import { fr, makeNewContractData, makeNewSideEffect, makeNewSideEffectLinkedToNoteHash, makeProof } from '@aztec/circuits.js/factories'; import { Fr } from '@aztec/foundation/fields'; import { createDebugLogger } from '@aztec/foundation/log'; import { to2Fields } from '@aztec/foundation/serialize'; @@ -168,10 +169,10 @@ describe('L1Publisher integration', () => { const processedTx = await makeProcessedTx(tx, kernelOutput, makeProof()); - processedTx.data.end.newCommitments = makeTuple(MAX_NEW_COMMITMENTS_PER_TX, fr, seed + 0x100); - processedTx.data.end.newNullifiers = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x200); - processedTx.data.end.newNullifiers[processedTx.data.end.newNullifiers.length - 1] = Fr.ZERO; - processedTx.data.end.newL2ToL1Msgs = makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, fr, seed + 0x300); + processedTx.data.end.newCommitments = makeTuple(MAX_NEW_COMMITMENTS_PER_TX, makeNewSideEffect, seed + 0x100); + processedTx.data.end.newNullifiers = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, makeNewSideEffectLinkedToNoteHash, seed + 0x200); + processedTx.data.end.newNullifiers[processedTx.data.end.newNullifiers.length - 1] = SideEffectLinkedToNoteHash.empty(); + processedTx.data.end.newL2ToL1Msgs = makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, makeNewSideEffect, seed + 0x300); processedTx.data.end.newContracts = [makeNewContractData(seed + 0x1000)]; processedTx.data.end.encryptedLogsHash = to2Fields(L2Block.computeKernelLogsHash(processedTx.encryptedLogs)); processedTx.data.end.unencryptedLogsHash = to2Fields(L2Block.computeKernelLogsHash(processedTx.unencryptedLogs)); diff --git a/yarn-project/pxe/src/kernel_prover/kernel_prover.test.ts b/yarn-project/pxe/src/kernel_prover/kernel_prover.test.ts index 7ca44bded925..1b185cc98722 100644 --- a/yarn-project/pxe/src/kernel_prover/kernel_prover.test.ts +++ b/yarn-project/pxe/src/kernel_prover/kernel_prover.test.ts @@ -9,6 +9,7 @@ import { PrivateCallStackItem, PrivateCircuitPublicInputs, ReadRequestMembershipWitness, + SideEffect, TxRequest, VK_TREE_HEIGHT, VerificationKey, @@ -50,7 +51,7 @@ describe('Kernel Prover', () => { const publicInputs = PrivateCircuitPublicInputs.empty(); publicInputs.newCommitments = makeTuple( MAX_NEW_COMMITMENTS_PER_CALL, - i => (i < newNoteIndices.length ? generateFakeCommitment(notes[newNoteIndices[i]]) : Fr.ZERO), + i => (i < newNoteIndices.length ? new SideEffect(generateFakeCommitment(notes[newNoteIndices[i]]), Fr.ZERO) : SideEffect.empty()), 0, ); return { @@ -75,9 +76,9 @@ describe('Kernel Prover', () => { const createProofOutput = (newNoteIndices: number[]) => { const publicInputs = KernelCircuitPublicInputs.empty(); - const commitments = newNoteIndices.map(idx => generateFakeSiloedCommitment(notes[idx])); + const commitments = newNoteIndices.map(idx => new SideEffect(generateFakeSiloedCommitment(notes[idx]), Fr.ZERO)); // TODO(AD) FIXME(AD) This cast is bad. Why is this not the correct length when this is called? - publicInputs.end.newCommitments = commitments as Tuple; + publicInputs.end.newCommitments = commitments as Tuple; return { publicInputs, proof: makeEmptyProof(), @@ -117,7 +118,7 @@ describe('Kernel Prover', () => { proofCreator = mock(); proofCreator.getSiloedCommitments.mockImplementation(publicInputs => - Promise.resolve(publicInputs.newCommitments.map(createFakeSiloedCommitment)), + Promise.resolve(publicInputs.newCommitments.map(com => createFakeSiloedCommitment(com.value))), ); proofCreator.createProofInit.mockResolvedValue(createProofOutput([])); proofCreator.createProofInner.mockResolvedValue(createProofOutput([])); diff --git a/yarn-project/pxe/src/kernel_prover/kernel_prover.ts b/yarn-project/pxe/src/kernel_prover/kernel_prover.ts index 2cb54b410718..97288f020402 100644 --- a/yarn-project/pxe/src/kernel_prover/kernel_prover.ts +++ b/yarn-project/pxe/src/kernel_prover/kernel_prover.ts @@ -18,6 +18,7 @@ import { PrivateKernelInputsOrdering, PrivateKernelPublicInputs, ReadRequestMembershipWitness, + SideEffect, TxRequest, VK_TREE_HEIGHT, VerificationKey, @@ -110,7 +111,7 @@ export class KernelProver { // and fill the non-transient ones in with sibling paths via oracle. const readRequestMembershipWitnesses = currentExecution.readRequestPartialWitnesses; for (let rr = 0; rr < readRequestMembershipWitnesses.length; rr++) { - if (currentExecution.callStackItem.publicInputs.readRequests[rr] == Fr.zero()) { + if (currentExecution.callStackItem.publicInputs.readRequests[rr].isEmpty()) { throw new Error( 'Number of read requests output from Noir circuit does not match number of read request commitment indices output from simulator.', ); @@ -264,12 +265,12 @@ export class KernelProver { * corresponding to the read request. In other words we have readRequests[i] == commitments[hints[i]]. */ private getReadRequestHints( - readRequests: Tuple, - commitments: Tuple, + readRequests: Tuple, + commitments: Tuple, ): Tuple { const hints = makeTuple(MAX_READ_REQUESTS_PER_TX, Fr.zero); - for (let i = 0; i < MAX_READ_REQUESTS_PER_TX && !readRequests[i].isZero(); i++) { - const equalToRR = (cmt: Fr) => cmt.equals(readRequests[i]); + for (let i = 0; i < MAX_READ_REQUESTS_PER_TX && !readRequests[i].isEmpty(); i++) { + const equalToRR = (cmt: SideEffect) => cmt.value.equals(readRequests[i].value); const result = commitments.findIndex(equalToRR); if (result == -1) { throw new Error( @@ -293,13 +294,14 @@ export class KernelProver { * corresponding to the nullified commitments. In other words we have nullifiedCommitments[i] == commitments[hints[i]]. */ private getNullifierHints( + // TODO replace nullifiedCommitments with array of newNullifier SideEffects nullifiedCommitments: Tuple, - commitments: Tuple, + commitments: Tuple, ): Tuple { const hints = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero); for (let i = 0; i < MAX_NEW_NULLIFIERS_PER_TX; i++) { if (!nullifiedCommitments[i].isZero() && !nullifiedCommitments[i].equals(new Fr(EMPTY_NULLIFIED_COMMITMENT))) { - const equalToCommitment = (cmt: Fr) => cmt.equals(nullifiedCommitments[i]); + const equalToCommitment = (cmt: SideEffect) => cmt.value.equals(nullifiedCommitments[i]); const result = commitments.findIndex(equalToCommitment); if (result == -1) { throw new Error( diff --git a/yarn-project/pxe/src/kernel_prover/proof_creator.ts b/yarn-project/pxe/src/kernel_prover/proof_creator.ts index 40d24e157593..e2bae4a745c4 100644 --- a/yarn-project/pxe/src/kernel_prover/proof_creator.ts +++ b/yarn-project/pxe/src/kernel_prover/proof_creator.ts @@ -105,7 +105,7 @@ export class KernelProofCreator implements ProofCreator { const wasm = await CircuitsWasm.get(); const contractAddress = publicInputs.callContext.storageContractAddress; - return publicInputs.newCommitments.map(commitment => siloCommitment(wasm, contractAddress, commitment)); + return publicInputs.newCommitments.map(commitment => siloCommitment(wasm, contractAddress, commitment.value)); } public async createProofInit(privateInputs: PrivateKernelInputsInit): Promise { diff --git a/yarn-project/pxe/src/pxe_service/pxe_service.ts b/yarn-project/pxe/src/pxe_service/pxe_service.ts index 83177e46e960..7f1b2a1cdf17 100644 --- a/yarn-project/pxe/src/pxe_service/pxe_service.ts +++ b/yarn-project/pxe/src/pxe_service/pxe_service.ts @@ -17,6 +17,7 @@ import { MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, PartialAddress, PublicCallRequest, + SideEffectWithRange, } from '@aztec/circuits.js'; import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis'; import { encodeArguments } from '@aztec/foundation/abi'; @@ -622,7 +623,7 @@ export class PXEService implements PXE { // Validate all items in enqueued public calls are in the kernel emitted stack const areEqual = enqueuedPublicCallsHashes.reduce( - (accum, enqueued) => accum && !!publicCallStack.find(item => item.equals(enqueued)), + (accum, enqueued) => accum && !!publicCallStack.find(item => item.value.equals(enqueued)), true, ); @@ -636,8 +637,8 @@ export class PXEService implements PXE { // Override kernel output publicInputs.end.publicCallStack = padArrayEnd( - enqueuedPublicCallsHashes, - Fr.ZERO, + enqueuedPublicCallsHashes.map(hash => new SideEffectWithRange(hash, Fr.ZERO, Fr.ZERO)), // set start side-effect counter here? + SideEffectWithRange.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, ); } diff --git a/yarn-project/sequencer-client/src/block_builder/solo_block_builder.test.ts b/yarn-project/sequencer-client/src/block_builder/solo_block_builder.test.ts index 7f61ad4e13e7..8a0c653ab454 100644 --- a/yarn-project/sequencer-client/src/block_builder/solo_block_builder.test.ts +++ b/yarn-project/sequencer-client/src/block_builder/solo_block_builder.test.ts @@ -15,6 +15,8 @@ import { Proof, PublicDataUpdateRequest, RootRollupPublicInputs, + SideEffect, + SideEffectLinkedToNoteHash, makeTuple, range, } from '@aztec/circuits.js'; @@ -23,6 +25,8 @@ import { fr, makeBaseOrMergeRollupPublicInputs, makeNewContractData, + makeNewSideEffect, + makeNewSideEffectLinkedToNoteHash, makePrivateKernelPublicInputsFinal, makeProof, makePublicCallRequest, @@ -245,13 +249,13 @@ describe('sequencer/solo_block_builder', () => { endL1ToL2MessagesTreeSnapshot: rootRollupOutput.endL1ToL2MessagesTreeSnapshot, startHistoricBlocksTreeSnapshot: rootRollupOutput.startHistoricBlocksTreeSnapshot, endHistoricBlocksTreeSnapshot: rootRollupOutput.endHistoricBlocksTreeSnapshot, - newCommitments, - newNullifiers, + newCommitments: newCommitments.map((sideeffect: SideEffect) => sideeffect.value), + newNullifiers: newNullifiers.map((sideeffect: SideEffectLinkedToNoteHash) => sideeffect.value), + newL2ToL1Msgs: newL2ToL1Msgs.map((sideeffect: SideEffect) => sideeffect.value), newContracts, newContractData, newPublicDataWrites, newL1ToL2Messages: mockL1ToL2Messages, - newL2ToL1Msgs, newEncryptedLogs, newUnencryptedLogs, }); @@ -315,10 +319,10 @@ describe('sequencer/solo_block_builder', () => { const processedTx = await makeProcessedTx(tx, kernelOutput, makeProof()); - processedTx.data.end.newCommitments = makeTuple(MAX_NEW_COMMITMENTS_PER_TX, fr, seed + 0x100); - processedTx.data.end.newNullifiers = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, fr, seed + 0x200); - processedTx.data.end.newNullifiers[tx.data.end.newNullifiers.length - 1] = Fr.ZERO; - processedTx.data.end.newL2ToL1Msgs = makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, fr, seed + 0x300); + processedTx.data.end.newCommitments = makeTuple(MAX_NEW_COMMITMENTS_PER_TX, makeNewSideEffect, seed + 0x100); + processedTx.data.end.newNullifiers = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, makeNewSideEffectLinkedToNoteHash, seed + 0x200); + processedTx.data.end.newNullifiers[tx.data.end.newNullifiers.length - 1] = SideEffectLinkedToNoteHash.empty(); + processedTx.data.end.newL2ToL1Msgs = makeTuple(MAX_NEW_L2_TO_L1_MSGS_PER_TX, makeNewSideEffect, seed + 0x300); processedTx.data.end.newContracts = [makeNewContractData(seed + 0x1000)]; processedTx.data.end.encryptedLogsHash = to2Fields(L2Block.computeKernelLogsHash(processedTx.encryptedLogs)); processedTx.data.end.unencryptedLogsHash = to2Fields(L2Block.computeKernelLogsHash(processedTx.unencryptedLogs)); @@ -398,12 +402,12 @@ describe('sequencer/solo_block_builder', () => { // new added values const tx = await makeEmptyProcessedTx(); - tx.data.end.newNullifiers[0] = new Fr( + tx.data.end.newNullifiers[0] = new SideEffectLinkedToNoteHash(new Fr( 10336601644835972678500657502133589897705389664587188571002640950065546264856n, - ); - tx.data.end.newNullifiers[1] = new Fr( + ), Fr.ZERO, Fr.ZERO); + tx.data.end.newNullifiers[1] = new SideEffectLinkedToNoteHash(new Fr( 17490072961923661940560522096125238013953043065748521735636170028491723851741n, - ); + ), Fr.ZERO, Fr.ZERO); const txs = [tx, await makeEmptyProcessedTx(), await makeEmptyProcessedTx(), await makeEmptyProcessedTx()]; diff --git a/yarn-project/sequencer-client/src/block_builder/solo_block_builder.ts b/yarn-project/sequencer-client/src/block_builder/solo_block_builder.ts index 0841fcb917e2..8bf85ec20cd4 100644 --- a/yarn-project/sequencer-client/src/block_builder/solo_block_builder.ts +++ b/yarn-project/sequencer-client/src/block_builder/solo_block_builder.ts @@ -32,6 +32,8 @@ import { RollupTypes, RootRollupInputs, RootRollupPublicInputs, + SideEffect, + SideEffectLinkedToNoteHash, VK_TREE_HEIGHT, VerificationKey, makeTuple, @@ -171,9 +173,9 @@ export class SoloBlockBuilder implements BlockBuilder { endL1ToL2MessagesTreeSnapshot, startHistoricBlocksTreeSnapshot, endHistoricBlocksTreeSnapshot, - newCommitments, - newNullifiers, - newL2ToL1Msgs, + newCommitments: newCommitments.map((sideeffect: SideEffect) => sideeffect.value), + newNullifiers: newNullifiers.map((sideeffect: SideEffectLinkedToNoteHash) => sideeffect.value), + newL2ToL1Msgs: newL2ToL1Msgs.map((sideeffect: SideEffect) => sideeffect.value), newContracts, newContractData, newPublicDataWrites, diff --git a/yarn-project/sequencer-client/src/sequencer/public_processor.test.ts b/yarn-project/sequencer-client/src/sequencer/public_processor.test.ts index 3e6686b3e617..17c5f45ec215 100644 --- a/yarn-project/sequencer-client/src/sequencer/public_processor.test.ts +++ b/yarn-project/sequencer-client/src/sequencer/public_processor.test.ts @@ -16,6 +16,7 @@ import { Proof, PublicCallRequest, PublicKernelPublicInputs, + SideEffectWithRange, makeEmptyProof, makeTuple, } from '@aztec/circuits.js'; @@ -82,7 +83,7 @@ describe('public_processor', () => { it('skips txs without public execution requests', async function () { const tx = mockTx(); - tx.data.end.publicCallStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, Fr.zero); + tx.data.end.publicCallStack = makeTuple(MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX, SideEffectWithRange.empty); const hash = await tx.getTxHash(); const [processed, failed] = await processor.process([tx]); @@ -145,11 +146,12 @@ describe('public_processor', () => { it('runs a tx with enqueued public calls', async function () { const callRequests: PublicCallRequest[] = [makePublicCallRequest(0x100), makePublicCallRequest(0x100)]; const callStackItems = await Promise.all(callRequests.map(call => call.toPublicCallStackItem())); - const callStackHashes = callStackItems.map(call => computeCallStackItemHash(wasm, call)); + // TODO(dbanks12): extract range side-effect counters from public inputs! + const callStackHashes = callStackItems.map(call => new SideEffectWithRange(computeCallStackItemHash(wasm, call), Fr.ZERO, Fr.ZERO)); const kernelOutput = makePrivateKernelPublicInputsFinal(0x10); - kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX); - kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX); + kernelOutput.end.publicCallStack = padArrayEnd(callStackHashes, SideEffectWithRange.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX); + kernelOutput.end.privateCallStack = padArrayEnd([], SideEffectWithRange.empty(), MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX); const tx = new Tx(kernelOutput, proof, TxL2Logs.random(2, 3), TxL2Logs.random(3, 2), callRequests, [ ExtendedContractData.random(), @@ -175,11 +177,12 @@ describe('public_processor', () => { it('runs a tx with an enqueued public call with nested execution', async function () { const callRequest: PublicCallRequest = makePublicCallRequest(0x100); const callStackItem = await callRequest.toPublicCallStackItem(); - const callStackHash = computeCallStackItemHash(wasm, callStackItem); + // TODO(dbanks12): extract range side-effect counters from public inputs! + const callStackHash = new SideEffectWithRange(computeCallStackItemHash(wasm, callStackItem), Fr.ZERO, Fr.ZERO); const kernelOutput = makePrivateKernelPublicInputsFinal(0x10); - kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], Fr.ZERO, MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX); - kernelOutput.end.privateCallStack = padArrayEnd([], Fr.ZERO, MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX); + kernelOutput.end.publicCallStack = padArrayEnd([callStackHash], SideEffectWithRange.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX); + kernelOutput.end.privateCallStack = padArrayEnd([], SideEffectWithRange.empty(), MAX_PRIVATE_CALL_STACK_LENGTH_PER_TX); const tx = new Tx( kernelOutput, @@ -229,7 +232,8 @@ function makePublicExecutionResult( tx: FunctionCall, nestedExecutions: PublicExecutionResult[] = [], ): PublicExecutionResult { - const callContext = new CallContext(from, tx.to, EthAddress.ZERO, tx.functionData.selector, false, false, false); + // TODO(dbanks12): use actual sideeffect counter? + const callContext = new CallContext(from, tx.to, EthAddress.ZERO, tx.functionData.selector, false, false, false, Fr.ZERO); const execution: PublicExecution = { callContext, contractAddress: tx.to, diff --git a/yarn-project/sequencer-client/src/sequencer/public_processor.ts b/yarn-project/sequencer-client/src/sequencer/public_processor.ts index 1f63c6f4b82a..f52da8cd1788 100644 --- a/yarn-project/sequencer-client/src/sequencer/public_processor.ts +++ b/yarn-project/sequencer-client/src/sequencer/public_processor.ts @@ -35,6 +35,9 @@ import { PublicKernelInputs, PublicKernelPublicInputs, RETURN_VALUES_LENGTH, + SideEffect, + SideEffectLinkedToNoteHash, + SideEffectWithRange, VK_TREE_HEIGHT, } from '@aztec/circuits.js'; import { computeCallStackItemHash, computeVarArgsHash } from '@aztec/circuits.js/abis'; @@ -146,7 +149,7 @@ export class PublicProcessor { } protected async processTx(tx: Tx): Promise { - if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isZero())) { + if (!isArrayEmpty(tx.data.end.publicCallStack, item => item.isEmpty())) { const [publicKernelOutput, publicKernelProof, newUnencryptedFunctionLogs] = await this.processEnqueuedPublicCalls( tx, ); @@ -252,7 +255,8 @@ export class PublicProcessor { const wasm = await CircuitsWasm.get(); const publicCallStack = mapTuple(callStackPreimages, item => - item.isEmpty() ? Fr.zero() : computeCallStackItemHash(wasm, item), + // TODO(dbanks12): extract range side-effect counters from public inputs! + item.isEmpty() ? SideEffectWithRange.empty() : new SideEffectWithRange(computeCallStackItemHash(wasm, item), Fr.ZERO, Fr.ZERO), ); // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1165) --> set this in Noir @@ -263,9 +267,9 @@ export class PublicProcessor { callContext: result.execution.callContext, proverAddress: AztecAddress.ZERO, argsHash: await computeVarArgsHash(wasm, result.execution.args), - newCommitments: padArrayEnd(result.newCommitments, Fr.ZERO, MAX_NEW_COMMITMENTS_PER_CALL), - newNullifiers: padArrayEnd(result.newNullifiers, Fr.ZERO, MAX_NEW_NULLIFIERS_PER_CALL), - newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, Fr.ZERO, MAX_NEW_L2_TO_L1_MSGS_PER_CALL), + newCommitments: padArrayEnd(result.newCommitments, SideEffect.empty(), MAX_NEW_COMMITMENTS_PER_CALL), + newNullifiers: padArrayEnd(result.newNullifiers, SideEffectLinkedToNoteHash.empty(), MAX_NEW_NULLIFIERS_PER_CALL), + newL2ToL1Msgs: padArrayEnd(result.newL2ToL1Messages, SideEffect.empty(), MAX_NEW_L2_TO_L1_MSGS_PER_CALL), returnValues: padArrayEnd(result.returnValues, Fr.ZERO, RETURN_VALUES_LENGTH), contractStorageReads: padArrayEnd( result.contractStorageReads, diff --git a/yarn-project/sequencer-client/src/sequencer/sequencer.ts b/yarn-project/sequencer-client/src/sequencer/sequencer.ts index c20146322628..a7a4dd6b01f0 100644 --- a/yarn-project/sequencer-client/src/sequencer/sequencer.ts +++ b/yarn-project/sequencer-client/src/sequencer/sequencer.ts @@ -258,7 +258,7 @@ export class Sequencer { continue; } - tx.data.end.newNullifiers.forEach(n => thisBlockNullifiers.add(n.toBigInt())); + tx.data.end.newNullifiers.forEach(n => thisBlockNullifiers.add(n.value.toBigInt())); validTxs.push(tx); if (validTxs.length >= this.maxTxsPerBlock) break; } @@ -327,10 +327,10 @@ export class Sequencer { */ protected isTxDoubleSpendSameBlock(tx: Tx | ProcessedTx, thisBlockNullifiers: Set): boolean { // We only consider non-empty nullifiers - const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isZero()); + const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isEmpty()); for (const nullifier of newNullifiers) { - if (thisBlockNullifiers.has(nullifier.toBigInt())) { + if (thisBlockNullifiers.has(nullifier.value.toBigInt())) { return true; } } @@ -345,10 +345,10 @@ export class Sequencer { */ protected async isTxDoubleSpend(tx: Tx | ProcessedTx): Promise { // We only consider non-empty nullifiers - const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isZero()); + const newNullifiers = tx.data.end.newNullifiers.filter(n => !n.isEmpty()); // Ditch this tx if it has a repeated nullifiers - const uniqNullifiers = new Set(newNullifiers.map(n => n.toBigInt())); + const uniqNullifiers = new Set(newNullifiers.map(n => n.value.toBigInt())); if (uniqNullifiers.size !== newNullifiers.length) return true; for (const nullifier of newNullifiers) {