Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
address_derivation.test.cpp
Go to the documentation of this file.
1#include "barretenberg/vm2/simulation/gadgets/address_derivation.hpp"
2
3#include <cstdint>
4#include <gmock/gmock.h>
5#include <gtest/gtest.h>
6#include <stdexcept>
7
8#include "barretenberg/aztec/aztec_constants.hpp"
9#include "barretenberg/crypto/poseidon2/poseidon2.hpp"
10#include "barretenberg/crypto/poseidon2/poseidon2_params.hpp"
11#include "barretenberg/vm2/common/aztec_types.hpp"
12#include "barretenberg/vm2/common/field.hpp"
13#include "barretenberg/vm2/simulation/events/address_derivation_event.hpp"
14#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
15#include "barretenberg/vm2/simulation/lib/contract_crypto.hpp"
16#include "barretenberg/vm2/simulation/standalone/pure_poseidon2.hpp"
17#include "barretenberg/vm2/simulation/testing/mock_ecc.hpp"
18#include "barretenberg/vm2/testing/fixtures.hpp"
19
20using ::testing::IsEmpty;
21using ::testing::Return;
22using ::testing::SizeIs;
23using ::testing::StrictMock;
24
25using poseidon2 = bb::crypto::Poseidon2<bb::crypto::Poseidon2Bn254ScalarFieldParams>;
26
27namespace bb::avm2::simulation {
28
29namespace {
30
31using simulation::PurePoseidon2;
32
33TEST(AvmSimulationAddressDerivationTest, Positive)
34{
35 EventEmitter<AddressDerivationEvent> address_derivation_event_emitter;
36 PurePoseidon2 poseidon2 = PurePoseidon2();
37 StrictMock<MockEcc> ecc;
38
39 AddressDerivation address_derivation(poseidon2, ecc, address_derivation_event_emitter);
40
41 ContractInstance instance = testing::random_contract_instance();
42 AztecAddress derived_address = compute_contract_address(instance);
43 std::vector<FF> salted_init_hash_inputs = { DOM_SEP__SALTED_INITIALIZATION_HASH,
44 instance.salt,
45 instance.initialization_hash,
46 instance.deployer,
47 instance.immutables_hash };
48 FF salted_init_hash = poseidon2::hash(salted_init_hash_inputs);
49
50 std::vector<FF> partial_address_inputs = { DOM_SEP__PARTIAL_ADDRESS,
51 instance.original_contract_class_id,
52 salted_init_hash };
53 FF partial_address = poseidon2::hash(partial_address_inputs);
54
55 FF public_keys_hash = hash_public_keys(instance.public_keys);
56
57 std::vector<FF> preaddress_inputs = { DOM_SEP__CONTRACT_ADDRESS_V2, public_keys_hash, partial_address };
58 FF preaddress = poseidon2::hash(preaddress_inputs);
59
60 EmbeddedCurvePoint g1 = EmbeddedCurvePoint::one();
61 EmbeddedCurvePoint preaddress_public_key = g1 * Fq(preaddress);
62 EXPECT_CALL(ecc, scalar_mul(g1, preaddress)).WillOnce(Return(preaddress_public_key));
63
64 EmbeddedCurvePoint address_point = preaddress_public_key + instance.public_keys.incoming_viewing_key;
65 EXPECT_CALL(ecc, add(preaddress_public_key, EmbeddedCurvePoint(instance.public_keys.incoming_viewing_key)))
66 .WillOnce(Return(address_point));
67
68 address_derivation.assert_derivation(derived_address, instance);
69
70 auto events = address_derivation_event_emitter.dump_events();
71 EXPECT_THAT(events, SizeIs(1));
72 EXPECT_EQ(events[0].instance, instance);
73 EXPECT_EQ(events[0].salted_initialization_hash, salted_init_hash);
74 EXPECT_EQ(events[0].partial_address, partial_address);
75 EXPECT_EQ(events[0].public_keys_hash, public_keys_hash);
76 EXPECT_EQ(events[0].preaddress, preaddress);
77 EXPECT_EQ(events[0].preaddress_public_key, preaddress_public_key);
78 EXPECT_EQ(events[0].address, derived_address);
79 EXPECT_EQ(events[0].address_point.x(), derived_address);
80
81 // Second derivation for the same address should be a cache hit and should not emit an event
82 address_derivation.assert_derivation(derived_address, instance);
83 events = address_derivation_event_emitter.dump_events();
84 EXPECT_THAT(events, IsEmpty());
85}
86
87TEST(AvmSimulationAddressDerivationTest, Negative)
88{
89 EventEmitter<AddressDerivationEvent> address_derivation_event_emitter;
90 PurePoseidon2 poseidon2 = PurePoseidon2();
91 StrictMock<MockEcc> ecc;
92
93 AddressDerivation address_derivation(poseidon2, ecc, address_derivation_event_emitter);
94
95 ContractInstance instance = testing::random_contract_instance();
96 AztecAddress derived_address = compute_contract_address(instance);
97
98 std::vector<FF> salted_init_hash_inputs = { DOM_SEP__SALTED_INITIALIZATION_HASH,
99 instance.salt,
100 instance.initialization_hash,
101 instance.deployer,
102 instance.immutables_hash };
103 FF salted_init_hash = poseidon2::hash(salted_init_hash_inputs);
104
105 std::vector<FF> partial_address_inputs = { DOM_SEP__PARTIAL_ADDRESS,
106 instance.original_contract_class_id,
107 salted_init_hash };
108 FF partial_address = poseidon2::hash(partial_address_inputs);
109
110 FF public_keys_hash = hash_public_keys(instance.public_keys);
111
112 std::vector<FF> preaddress_inputs = { DOM_SEP__CONTRACT_ADDRESS_V2, public_keys_hash, partial_address };
113 FF preaddress = poseidon2::hash(preaddress_inputs);
114
115 EmbeddedCurvePoint g1 = EmbeddedCurvePoint::one();
116 EmbeddedCurvePoint preaddress_public_key = g1 * Fq(preaddress);
117 EXPECT_CALL(ecc, scalar_mul(g1, preaddress)).WillOnce(Return(preaddress_public_key));
118
119 EmbeddedCurvePoint address_point = preaddress_public_key + instance.public_keys.incoming_viewing_key;
120 EXPECT_CALL(ecc, add(preaddress_public_key, EmbeddedCurvePoint(instance.public_keys.incoming_viewing_key)))
121 .WillOnce(Return(address_point));
122
123 // Should fail on incorrect derived address.
124 EXPECT_THROW(address_derivation.assert_derivation(derived_address + 1, instance), std::runtime_error);
125
126 // Should fail on mutated instance for unseen address.
127 instance.public_keys.nullifier_key_hash = FF(0xdeadbeef);
128
129 public_keys_hash = hash_public_keys(instance.public_keys);
130 preaddress_inputs = { DOM_SEP__CONTRACT_ADDRESS_V2, public_keys_hash, partial_address };
131 preaddress = poseidon2::hash(preaddress_inputs);
132 preaddress_public_key = g1 * Fq(preaddress);
133 address_point = preaddress_public_key + instance.public_keys.incoming_viewing_key;
134
135 EXPECT_CALL(ecc, scalar_mul(g1, preaddress)).WillOnce(Return(preaddress_public_key));
136 EXPECT_CALL(ecc, add(preaddress_public_key, EmbeddedCurvePoint(instance.public_keys.incoming_viewing_key)))
137 .WillOnce(Return(address_point));
138
139 // The below fails and does not emit an event.
140 EXPECT_THROW(address_derivation.assert_derivation(derived_address, instance), std::runtime_error);
141 EXPECT_THAT(address_derivation_event_emitter.dump_events(), IsEmpty());
142
143 // Perform a successful derivation for the mutated instance above.
144 EXPECT_CALL(ecc, scalar_mul(g1, preaddress)).WillOnce(Return(preaddress_public_key));
145 EXPECT_CALL(ecc, add(preaddress_public_key, EmbeddedCurvePoint(instance.public_keys.incoming_viewing_key)))
146 .WillOnce(Return(address_point));
147 // The below succeeds, emits an event, and stores the address in the cached_derivations cache.
148 address_derivation.assert_derivation(address_point.x(), instance);
149 EXPECT_THAT(address_derivation_event_emitter.dump_events(), SizeIs(1));
150
151 // Should fail on mutated instance for seen address.
152 ContractInstance new_instance = instance;
153 new_instance.deployer += 1;
154 // Note: EXPECT_CALLs not required since the address is cached.
155 EXPECT_THROW(address_derivation.assert_derivation(address_point.x(), new_instance), std::runtime_error);
156 EXPECT_THAT(address_derivation_event_emitter.dump_events(), IsEmpty());
157
158 // The below succeeds and hits the cache, so does not emit an event.
159 address_derivation.assert_derivation(address_point.x(), instance);
160 EXPECT_THAT(address_derivation_event_emitter.dump_events(), IsEmpty());
161}
162
163} // namespace
164} // namespace bb::avm2::simulation
address_derivation_event.hpp
aztec_types.hpp
bb::crypto::Poseidon2
Native Poseidon2 hash function implementation.
Definition poseidon2.hpp:22
bb::crypto::Poseidon2< crypto::Poseidon2Bn254ScalarFieldParams >::hash
static FF hash(const std::vector< FF > &input)
Hashes a vector of field elements.
bb::group
group class. Represents an elliptic curve group element. Group is parametrised by Fq and Fr
Definition group.hpp:38
contract_crypto.hpp
event_emitter.hpp
mock_ecc.hpp
bb::avm2::simulation
AVM range check gadget for witness generation.
Definition address_derivation_event.hpp:6
bb::avm2::testing::random_contract_instance
ContractInstance random_contract_instance()
Definition fixtures.cpp:162
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::avm2::EmbeddedCurvePoint
StandardAffinePoint< AvmFlavorSettings::EmbeddedCurve::AffineElement > EmbeddedCurvePoint
Definition field.hpp:12
bb::avm2::Fq
AvmFlavorSettings::G1::Fq Fq
Definition field.hpp:11
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
poseidon2_params.hpp
pure_poseidon2.hpp
address_derivation.hpp