Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
tx_trace.test.cpp
Go to the documentation of this file.
1#include "barretenberg/vm2/tracegen/tx_trace.hpp"
2
3#include <cstdint>
4#include <gmock/gmock.h>
5#include <gtest/gtest.h>
6
7#include "barretenberg/vm2/common/aztec_constants.hpp"
8#include "barretenberg/vm2/constraining/flavor_settings.hpp"
9#include "barretenberg/vm2/constraining/full_row.hpp"
10#include "barretenberg/vm2/simulation/events/tx_events.hpp"
11#include "barretenberg/vm2/testing/fixtures.hpp"
12#include "barretenberg/vm2/testing/instruction_builder.hpp"
13#include "barretenberg/vm2/testing/macros.hpp"
14#include "barretenberg/vm2/tracegen/range_check_trace.hpp"
15#include "barretenberg/vm2/tracegen/test_trace_container.hpp"
16
17namespace bb::avm2::tracegen {
18namespace {
19
20using enum ::bb::avm2::WireOpCode;
21
22using ::testing::AllOf;
23
24TEST(TxTraceGenTest, EnqueuedCallEvent)
25{
26 TestTraceContainer trace;
27 TxTraceBuilder builder;
28
29 auto msg_sender = FF::random_element();
30 auto contract_address = FF::random_element();
31 auto calldata_hash = FF::random_element();
32
33 simulation::TxStartupEvent startup_event = {
34 .state = { .gas_used = { 500, 1000 }, .tree_states = {}, .written_public_data_slots_tree_snapshot = {} },
35 .gas_limit = { 1000, 2000 },
36 .teardown_gas_limit = { 0, 0 },
37 .phase_lengths = { .setup = 1 },
38 };
39
40 simulation::TxPhaseEvent tx_event = {
41 .phase = TransactionPhase::SETUP,
42 .state_before = {},
43 .state_after = {},
44 .reverted = false,
45 .event =
46 simulation::EnqueuedCallEvent{
47 .msg_sender = msg_sender,
48 .contract_address = contract_address,
49 .is_static = false,
50 .calldata_size = 2,
51 .calldata_hash = calldata_hash,
52 .success = true,
53 },
54 };
55
56 builder.process({ startup_event, tx_event }, trace);
57 auto rows = trace.as_rows();
58 ASSERT_EQ(rows.size(), 2); // 0th precomputed, setup
59
60 // Setup
61 EXPECT_THAT(rows[1],
62 AllOf(ROW_FIELD_EQ(tx_sel, 1),
63 ROW_FIELD_EQ(tx_phase_value, static_cast<uint8_t>(TransactionPhase::SETUP)),
64 ROW_FIELD_EQ(tx_start_phase, 1),
65 ROW_FIELD_EQ(tx_is_public_call_request, 1),
66 ROW_FIELD_EQ(tx_read_pi_length_offset,
67 AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_SETUP_CALLS_ROW_IDX),
68 ROW_FIELD_EQ(tx_read_pi_offset, AVM_PUBLIC_INPUTS_PUBLIC_SETUP_CALL_REQUESTS_ROW_IDX),
69 ROW_FIELD_EQ(tx_remaining_phase_counter, 1),
70 ROW_FIELD_EQ(tx_remaining_phase_inv, 1),
71 ROW_FIELD_EQ(tx_msg_sender, msg_sender),
72 ROW_FIELD_EQ(tx_contract_addr, contract_address),
73 ROW_FIELD_EQ(tx_calldata_size, 2),
74 ROW_FIELD_EQ(tx_calldata_hash, calldata_hash),
75 ROW_FIELD_EQ(tx_end_phase, 1),
76 ROW_FIELD_EQ(tx_is_static, false)));
77};
78
79TEST(TxTraceGenTest, CollectFeeEvent)
80{
81 TestTraceContainer trace;
82 TxTraceBuilder builder;
83
84 auto fee_payer = FF::random_element();
85 auto fee_payer_balance = FF::neg_one();
86 auto effective_fee_per_da_gas = 100;
87 auto effective_fee_per_l2_gas = 200;
88 auto prev_da_gas_used = 1000;
89 auto prev_l2_gas_used = 500;
90 auto fee = effective_fee_per_da_gas * prev_da_gas_used + effective_fee_per_l2_gas * prev_l2_gas_used;
91
92 simulation::TxStartupEvent startup_event = {
93 .state = { .gas_used = { 500, 1000 }, .tree_states = {}, .written_public_data_slots_tree_snapshot = {} },
94 .gas_limit = { 1000, 2000 },
95 .teardown_gas_limit = { 0, 0 },
96 };
97
98 simulation::TxPhaseEvent tx_event = { .phase = TransactionPhase::COLLECT_GAS_FEES,
99 .state_before = {},
100 .state_after = {},
101 .reverted = false,
102 .event = simulation::CollectGasFeeEvent{
103 .effective_fee_per_da_gas =
104 static_cast<uint128_t>(effective_fee_per_da_gas),
105 .effective_fee_per_l2_gas =
106 static_cast<uint128_t>(effective_fee_per_l2_gas),
107 .fee_payer = fee_payer,
108 .fee_payer_balance = fee_payer_balance,
109 .fee = fee,
110 } };
111
112 builder.process({ startup_event, tx_event }, trace);
113 auto rows = trace.as_rows();
114 ASSERT_EQ(rows.size(), 2); // 0th precomputed, collect-gas-fees
115
116 EXPECT_THAT(rows[1],
117 AllOf(ROW_FIELD_EQ(tx_sel, 1),
118 ROW_FIELD_EQ(tx_phase_value, static_cast<uint8_t>(TransactionPhase::COLLECT_GAS_FEES)),
119 ROW_FIELD_EQ(tx_is_padded, 0),
120 ROW_FIELD_EQ(tx_start_phase, 1),
121 ROW_FIELD_EQ(tx_sel_read_phase_length, 0),
122 ROW_FIELD_EQ(tx_end_phase, 1),
123 ROW_FIELD_EQ(tx_prev_da_gas_used, prev_da_gas_used),
124 ROW_FIELD_EQ(tx_prev_l2_gas_used, prev_l2_gas_used),
125 ROW_FIELD_EQ(tx_read_pi_offset, AVM_PUBLIC_INPUTS_EFFECTIVE_GAS_FEES_ROW_IDX),
126 ROW_FIELD_EQ(tx_read_pi_length_offset, 0),
127 ROW_FIELD_EQ(tx_write_pi_offset, AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX),
128 ROW_FIELD_EQ(tx_remaining_phase_counter, 1),
129 ROW_FIELD_EQ(tx_remaining_phase_inv, FF(1).invert()),
130 ROW_FIELD_EQ(tx_remaining_phase_minus_one_inv, 0),
131 ROW_FIELD_EQ(tx_is_collect_fee, 1),
132 ROW_FIELD_EQ(tx_effective_fee_per_da_gas, FF(effective_fee_per_da_gas)),
133 ROW_FIELD_EQ(tx_effective_fee_per_l2_gas, FF(effective_fee_per_l2_gas)),
134 ROW_FIELD_EQ(tx_fee_payer, fee_payer),
135 ROW_FIELD_EQ(tx_fee_payer_pi_offset, AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX),
136 ROW_FIELD_EQ(tx_fee, fee),
137 ROW_FIELD_EQ(tx_fee_payer_balance, fee_payer_balance),
138 ROW_FIELD_EQ(tx_next_da_gas_used, prev_da_gas_used),
139 ROW_FIELD_EQ(tx_next_l2_gas_used, prev_l2_gas_used),
140 ROW_FIELD_EQ(tx_uint32_max, 0xffffffff)));
141};
142
143TEST(TxTraceGenTest, PadTreesEvent)
144{
145 TestTraceContainer trace;
146 TxTraceBuilder builder;
147
148 simulation::TxStartupEvent startup_event = {
149 .state = { .gas_used = { 500, 1000 }, .tree_states = {}, .written_public_data_slots_tree_snapshot = {} },
150 .gas_limit = { 1000, 2000 },
151 .teardown_gas_limit = { 0, 0 },
152 };
153
154 simulation::TxPhaseEvent tx_event = { .phase = TransactionPhase::TREE_PADDING,
155 .state_before = {
156 .tree_states = {
157 .noteHashTree = {
158 .tree = {
159 .root = 27,
160 .nextAvailableLeafIndex = 65,
161 },
162 .counter = 1
163 },
164 .nullifierTree = {
165 .tree = {
166 .root = 28,
167 .nextAvailableLeafIndex = 127,
168 },
169 .counter = 63
170 },
171 },
172 },
173 .state_after = {
174 .tree_states = {
175 .noteHashTree = {
176 .tree = {
177 .root = 27,
178 .nextAvailableLeafIndex = 128,
179 },
180 .counter = 1
181 },
182 .nullifierTree = {
183 .tree = {
184 .root = 28,
185 .nextAvailableLeafIndex = 128,
186 },
187 .counter = 63
188 },
189 },
190 },
191 .reverted = false,
192 .event = simulation::PadTreesEvent{} };
193
194 builder.process({ startup_event, tx_event }, trace);
195 auto rows = trace.as_rows();
196 ASSERT_EQ(rows.size(), 2); // 0th precomputed, tree-padding
197
198 EXPECT_THAT(rows[1],
199 AllOf(ROW_FIELD_EQ(tx_sel, 1),
200 ROW_FIELD_EQ(tx_phase_value, static_cast<uint8_t>(TransactionPhase::TREE_PADDING)),
201 ROW_FIELD_EQ(tx_start_phase, 1),
202 ROW_FIELD_EQ(tx_end_phase, 1),
203 ROW_FIELD_EQ(tx_is_tree_padding, 1),
204 ROW_FIELD_EQ(tx_remaining_phase_counter, 1),
205 ROW_FIELD_EQ(tx_remaining_phase_inv, 1),
206 ROW_FIELD_EQ(tx_sel_can_emit_note_hash, 1),
207 ROW_FIELD_EQ(tx_sel_can_emit_nullifier, 1),
208 ROW_FIELD_EQ(tx_prev_note_hash_tree_root, 27),
209 ROW_FIELD_EQ(tx_prev_note_hash_tree_size, 65),
210 ROW_FIELD_EQ(tx_prev_num_note_hashes_emitted, 1),
211 ROW_FIELD_EQ(tx_next_note_hash_tree_root, 27),
212 ROW_FIELD_EQ(tx_next_note_hash_tree_size, 128),
213 ROW_FIELD_EQ(tx_prev_nullifier_tree_root, 28),
214 ROW_FIELD_EQ(tx_prev_nullifier_tree_size, 127),
215 ROW_FIELD_EQ(tx_prev_num_nullifiers_emitted, 63),
216 ROW_FIELD_EQ(tx_next_nullifier_tree_root, 28),
217 ROW_FIELD_EQ(tx_next_nullifier_tree_size, 128)));
218}
219
220TEST(TxTraceGenTest, CleanupEvent)
221{
222 TestTraceContainer trace;
223 TxTraceBuilder builder;
224
225 simulation::TxStartupEvent startup_event = {
226 .state = { .gas_used = { 500, 1000 }, .tree_states = {}, .written_public_data_slots_tree_snapshot = {} },
227 .gas_limit = { 1000, 2000 },
228 .teardown_gas_limit = { 0, 0 },
229 };
230
231 simulation::TxPhaseEvent tx_event = { .phase = TransactionPhase::CLEANUP,
232 .state_before = {},
233 .state_after = {},
234 .reverted = false,
235 .event = simulation::CleanupEvent{} };
236
237 builder.process({ startup_event, tx_event }, trace);
238 auto rows = trace.as_rows();
239 ASSERT_EQ(rows.size(), 2); // 0th precomputed, cleanup
240
241 EXPECT_THAT(
242 rows[1],
243 AllOf(ROW_FIELD_EQ(tx_sel, 1),
244 ROW_FIELD_EQ(tx_phase_value, static_cast<uint8_t>(TransactionPhase::CLEANUP)),
245 ROW_FIELD_EQ(tx_start_phase, 1),
246 ROW_FIELD_EQ(tx_end_phase, 1),
247 ROW_FIELD_EQ(tx_is_cleanup, 1),
248 ROW_FIELD_EQ(tx_remaining_phase_counter, 1),
249 ROW_FIELD_EQ(tx_remaining_phase_inv, 1),
250 ROW_FIELD_EQ(tx_note_hash_pi_offset, AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX),
251 ROW_FIELD_EQ(tx_should_read_note_hash_tree, 1),
252 ROW_FIELD_EQ(tx_nullifier_pi_offset, AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NULLIFIER_TREE_ROW_IDX),
253 ROW_FIELD_EQ(tx_should_read_nullifier_tree, 1),
254 ROW_FIELD_EQ(tx_public_data_pi_offset, AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_PUBLIC_DATA_TREE_ROW_IDX),
255 ROW_FIELD_EQ(tx_should_read_public_data_tree, 1),
256 ROW_FIELD_EQ(tx_l1_l2_pi_offset, AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX),
257 ROW_FIELD_EQ(tx_should_read_l1_l2_tree, 1),
258 ROW_FIELD_EQ(tx_gas_used_pi_offset, AVM_PUBLIC_INPUTS_END_GAS_USED_ROW_IDX),
259 ROW_FIELD_EQ(tx_should_read_gas_used, 1)));
260}
261
262} // namespace
263} // namespace bb::avm2::tracegen
aztec_constants.hpp
AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX
#define AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_L1_TO_L2_MESSAGE_TREE_ROW_IDX
Definition aztec_constants.hpp:152
AVM_PUBLIC_INPUTS_EFFECTIVE_GAS_FEES_ROW_IDX
#define AVM_PUBLIC_INPUTS_EFFECTIVE_GAS_FEES_ROW_IDX
Definition aztec_constants.hpp:125
AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX
#define AVM_PUBLIC_INPUTS_FEE_PAYER_ROW_IDX
Definition aztec_constants.hpp:126
AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX
#define AVM_PUBLIC_INPUTS_TRANSACTION_FEE_ROW_IDX
Definition aztec_constants.hpp:168
AVM_PUBLIC_INPUTS_END_GAS_USED_ROW_IDX
#define AVM_PUBLIC_INPUTS_END_GAS_USED_ROW_IDX
Definition aztec_constants.hpp:156
AVM_PUBLIC_INPUTS_PUBLIC_SETUP_CALL_REQUESTS_ROW_IDX
#define AVM_PUBLIC_INPUTS_PUBLIC_SETUP_CALL_REQUESTS_ROW_IDX
Definition aztec_constants.hpp:132
AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NULLIFIER_TREE_ROW_IDX
#define AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NULLIFIER_TREE_ROW_IDX
Definition aztec_constants.hpp:154
AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX
#define AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_NOTE_HASH_TREE_ROW_IDX
Definition aztec_constants.hpp:153
AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_SETUP_CALLS_ROW_IDX
#define AVM_PUBLIC_INPUTS_PUBLIC_CALL_REQUEST_ARRAY_LENGTHS_SETUP_CALLS_ROW_IDX
Definition aztec_constants.hpp:129
AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_PUBLIC_DATA_TREE_ROW_IDX
#define AVM_PUBLIC_INPUTS_END_TREE_SNAPSHOTS_PUBLIC_DATA_TREE_ROW_IDX
Definition aztec_constants.hpp:155
bb::avm2::tracegen::AluTraceBuilder::process
void process(const simulation::EventEmitterInterface< simulation::AluEvent >::Container &events, TraceContainer &trace)
Definition alu_trace.cpp:308
bb::avm2::tracegen::TestTraceContainer::as_rows
std::vector< AvmFullRowConstRef > as_rows() const
Definition test_trace_container.cpp:28
builder
AluTraceBuilder builder
Definition alu.test.cpp:123
trace
TestTraceContainer trace
Definition data_copy.test.cpp:62
contract_address
AztecAddress contract_address
Definition written_public_data_slots_tree_check.test.cpp:97
flavor_settings.hpp
full_row.hpp
instruction_builder.hpp
ROW_FIELD_EQ
#define ROW_FIELD_EQ(field_name, expression)
Definition macros.hpp:15
bb::avm2::simulation::TEST
TEST(EmitUnencryptedLogTest, Basic)
Definition emit_unencrypted_log.test.cpp:20
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
range_check_trace.hpp
uint128_t
unsigned __int128 uint128_t
Definition serialize.hpp:44
test_trace_container.hpp
tx_events.hpp
tx_trace.hpp