Barretenberg
The ZK-SNARK library at the core of Aztec
Loading...
Searching...
No Matches
aztec_types.test.cpp
Go to the documentation of this file.
1#include "barretenberg/vm2/common/aztec_types.hpp"
2
3#include <gmock/gmock.h>
4#include <gtest/gtest.h>
5
6namespace bb::avm2 {
7namespace {
8
9using ::testing::ElementsAre;
10using ::testing::Eq;
11
12TEST(PublicLogsTest, DefaultConstructor)
13{
14 PublicLogs public_logs;
15 EXPECT_EQ(public_logs.length, 0);
16 EXPECT_EQ(public_logs.payload.size(), FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH);
17 // All payload elements should be zero-initialized
18 for (size_t i = 0; i < FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH; ++i) {
19 EXPECT_EQ(public_logs.payload[i], FF(0));
20 }
21}
22
23TEST(PublicLogsTest, ConstructorWithLengthAndPayload)
24{
25 std::array<FF, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH> payload{};
26 payload[0] = FF(3); // log length
27 payload[1] = FF(0x1234); // contract address
28 payload[2] = FF(100);
29 payload[3] = FF(200);
30 payload[4] = FF(300);
31
32 uint32_t length = 5; // 2 (header) + 3 (fields)
33 PublicLogs public_logs(length, payload);
34
35 EXPECT_EQ(public_logs.length, length);
36 EXPECT_EQ(public_logs.payload[0], FF(3));
37 EXPECT_EQ(public_logs.payload[1], FF(0x1234));
38 EXPECT_EQ(public_logs.payload[2], FF(100));
39 EXPECT_EQ(public_logs.payload[3], FF(200));
40 EXPECT_EQ(public_logs.payload[4], FF(300));
41}
42
43TEST(PublicLogsTest, ConstructorFromEmptyVector)
44{
45 std::vector<PublicLog> logs;
46 PublicLogs public_logs(logs);
47
48 EXPECT_EQ(public_logs.length, 0);
49 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
50 EXPECT_TRUE(recovered_logs.empty());
51}
52
53TEST(PublicLogsTest, ConstructorFromSingleLog)
54{
55 AztecAddress contract_address = FF(0xdeadbeef);
56 std::vector<FF> fields = { FF(1), FF(2), FF(3) };
57 PublicLog log{ fields, contract_address };
58
59 std::vector<PublicLog> logs = { log };
60 PublicLogs public_logs(logs);
61
62 EXPECT_EQ(public_logs.length, fields.size() + PUBLIC_LOG_HEADER_LENGTH);
63 EXPECT_EQ(public_logs.payload[0], FF(fields.size()));
64 EXPECT_EQ(public_logs.payload[1], contract_address);
65 EXPECT_EQ(public_logs.payload[2], FF(1));
66 EXPECT_EQ(public_logs.payload[3], FF(2));
67 EXPECT_EQ(public_logs.payload[4], FF(3));
68}
69
70TEST(PublicLogsTest, ConstructorFromMultipleLogs)
71{
72 AztecAddress addr1 = FF(0x1111);
73 AztecAddress addr2 = FF(0x2222);
74 AztecAddress addr3 = FF(0x3333);
75
76 std::vector<PublicLog> logs = {
77 PublicLog{ { FF(1), FF(2), FF(3) }, addr1 },
78 PublicLog{ { FF(4), FF(5) }, addr2 },
79 PublicLog{ { FF(6) }, addr3 },
80 };
81
82 PublicLogs public_logs(logs);
83
84 // First log: length=3, addr=0x1111, fields=[1,2,3] -> total 5
85 // Second log: length=2, addr=0x2222, fields=[4,5] -> total 4
86 // Third log: length=1, addr=0x3333, fields=[6] -> total 3
87 // Total: 5 + 4 + 3 = 12
88 EXPECT_EQ(public_logs.length, 12);
89
90 // Verify first log
91 EXPECT_EQ(public_logs.payload[0], FF(3));
92 EXPECT_EQ(public_logs.payload[1], addr1);
93 EXPECT_EQ(public_logs.payload[2], FF(1));
94 EXPECT_EQ(public_logs.payload[3], FF(2));
95 EXPECT_EQ(public_logs.payload[4], FF(3));
96
97 // Verify second log
98 EXPECT_EQ(public_logs.payload[5], FF(2));
99 EXPECT_EQ(public_logs.payload[6], addr2);
100 EXPECT_EQ(public_logs.payload[7], FF(4));
101 EXPECT_EQ(public_logs.payload[8], FF(5));
102
103 // Verify third log
104 EXPECT_EQ(public_logs.payload[9], FF(1));
105 EXPECT_EQ(public_logs.payload[10], addr3);
106 EXPECT_EQ(public_logs.payload[11], FF(6));
107}
108
109TEST(PublicLogsTest, AddLogToEmpty)
110{
111 PublicLogs public_logs;
112 AztecAddress contract_address = FF(0xabcd);
113 std::vector<FF> fields = { FF(10), FF(20) };
114 PublicLog log{ fields, contract_address };
115
116 public_logs.add_log(log);
117
118 EXPECT_EQ(public_logs.length, fields.size() + PUBLIC_LOG_HEADER_LENGTH);
119 EXPECT_EQ(public_logs.payload[0], FF(fields.size()));
120 EXPECT_EQ(public_logs.payload[1], contract_address);
121 EXPECT_EQ(public_logs.payload[2], FF(10));
122 EXPECT_EQ(public_logs.payload[3], FF(20));
123}
124
125TEST(PublicLogsTest, AddMultipleLogs)
126{
127 PublicLogs public_logs;
128
129 AztecAddress addr1 = FF(0xaaaa);
130 PublicLog log1{ { FF(1), FF(2) }, addr1 };
131 public_logs.add_log(log1);
132
133 AztecAddress addr2 = FF(0xbbbb);
134 PublicLog log2{ { FF(3), FF(4), FF(5) }, addr2 };
135 public_logs.add_log(log2);
136
137 EXPECT_EQ(public_logs.length, 2 + 2 + 2 + 3); // 2 logs with headers: (2+2) + (2+3) = 9
138
139 // Verify first log
140 EXPECT_EQ(public_logs.payload[0], FF(2));
141 EXPECT_EQ(public_logs.payload[1], addr1);
142 EXPECT_EQ(public_logs.payload[2], FF(1));
143 EXPECT_EQ(public_logs.payload[3], FF(2));
144
145 // Verify second log
146 EXPECT_EQ(public_logs.payload[4], FF(3));
147 EXPECT_EQ(public_logs.payload[5], addr2);
148 EXPECT_EQ(public_logs.payload[6], FF(3));
149 EXPECT_EQ(public_logs.payload[7], FF(4));
150 EXPECT_EQ(public_logs.payload[8], FF(5));
151}
152
153TEST(PublicLogsTest, AddLogWithEmptyFields)
154{
155 PublicLogs public_logs;
156 AztecAddress contract_address = FF(0x1234);
157 PublicLog log{ {}, contract_address };
158
159 public_logs.add_log(log);
160
161 EXPECT_EQ(public_logs.length, PUBLIC_LOG_HEADER_LENGTH);
162 EXPECT_EQ(public_logs.payload[0], FF(0));
163 EXPECT_EQ(public_logs.payload[1], contract_address);
164}
165
166TEST(PublicLogsTest, FromLogsStaticMethod)
167{
168 std::vector<PublicLog> logs = {
169 PublicLog{ { FF(1) }, FF(0x1111) },
170 PublicLog{ { FF(2), FF(3) }, FF(0x2222) },
171 };
172
173 PublicLogs public_logs = PublicLogs::from_logs(logs);
174
175 EXPECT_EQ(public_logs.length, 1 + 2 + 2 + 2); // (1+2) + (2+2) = 7
176 EXPECT_EQ(public_logs.payload[0], FF(1));
177 EXPECT_EQ(public_logs.payload[1], FF(0x1111));
178 EXPECT_EQ(public_logs.payload[2], FF(1));
179 EXPECT_EQ(public_logs.payload[3], FF(2));
180 EXPECT_EQ(public_logs.payload[4], FF(0x2222));
181 EXPECT_EQ(public_logs.payload[5], FF(2));
182 EXPECT_EQ(public_logs.payload[6], FF(3));
183}
184
185TEST(PublicLogsTest, ToLogsEmpty)
186{
187 PublicLogs public_logs;
188 std::vector<PublicLog> logs = public_logs.to_logs();
189 EXPECT_TRUE(logs.empty());
190}
191
192TEST(PublicLogsTest, ToLogsSingle)
193{
194 PublicLogs public_logs;
195 AztecAddress contract_address = FF(0xbeef);
196 std::vector<FF> fields = { FF(42), FF(43) };
197 PublicLog original_log{ fields, contract_address };
198 public_logs.add_log(original_log);
199
200 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
201
202 ASSERT_EQ(recovered_logs.size(), 1);
203 EXPECT_EQ(recovered_logs[0].contract_address, contract_address);
204 EXPECT_THAT(recovered_logs[0].fields, ElementsAre(FF(42), FF(43)));
205}
206
207TEST(PublicLogsTest, ToLogsMultiple)
208{
209 std::vector<PublicLog> original_logs = {
210 PublicLog{ { FF(1), FF(2), FF(3) }, FF(0x1111) },
211 PublicLog{ { FF(4), FF(5) }, FF(0x2222) },
212 PublicLog{ { FF(6) }, FF(0x3333) },
213 };
214
215 PublicLogs public_logs(original_logs);
216 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
217
218 ASSERT_EQ(recovered_logs.size(), 3);
219
220 EXPECT_EQ(recovered_logs[0].contract_address, FF(0x1111));
221 EXPECT_THAT(recovered_logs[0].fields, ElementsAre(FF(1), FF(2), FF(3)));
222
223 EXPECT_EQ(recovered_logs[1].contract_address, FF(0x2222));
224 EXPECT_THAT(recovered_logs[1].fields, ElementsAre(FF(4), FF(5)));
225
226 EXPECT_EQ(recovered_logs[2].contract_address, FF(0x3333));
227 EXPECT_THAT(recovered_logs[2].fields, ElementsAre(FF(6)));
228}
229
230TEST(PublicLogsTest, RoundTripConversion)
231{
232 std::vector<PublicLog> original_logs = {
233 PublicLog{ { FF(10), FF(20), FF(30) }, FF(0xaaaa) },
234 PublicLog{ { FF(40), FF(50) }, FF(0xbbbb) },
235 PublicLog{ { FF(60) }, FF(0xcccc) },
236 PublicLog{ {}, FF(0xdddd) }, // Empty fields
237 };
238
239 PublicLogs public_logs(original_logs);
240 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
241
242 ASSERT_EQ(recovered_logs.size(), original_logs.size());
243
244 for (size_t i = 0; i < original_logs.size(); ++i) {
245 EXPECT_EQ(recovered_logs[i].contract_address, original_logs[i].contract_address);
246 EXPECT_EQ(recovered_logs[i].fields.size(), original_logs[i].fields.size());
247 for (size_t j = 0; j < original_logs[i].fields.size(); ++j) {
248 EXPECT_EQ(recovered_logs[i].fields[j], original_logs[i].fields[j]);
249 }
250 }
251}
252
253TEST(PublicLogsTest, EqualityOperator)
254{
255 std::vector<PublicLog> logs = {
256 PublicLog{ { FF(1), FF(2) }, FF(0x1111) },
257 PublicLog{ { FF(3) }, FF(0x2222) },
258 };
259
260 PublicLogs public_logs1(logs);
261 PublicLogs public_logs2(logs);
262
263 EXPECT_EQ(public_logs1, public_logs2);
264}
265
266TEST(PublicLogsTest, EqualityOperatorDifferentLength)
267{
268 PublicLogs public_logs1;
269 public_logs1.add_log(PublicLog{ { FF(1) }, FF(0x1111) });
270
271 PublicLogs public_logs2;
272 public_logs2.add_log(PublicLog{ { FF(1) }, FF(0x1111) });
273 public_logs2.add_log(PublicLog{ { FF(2) }, FF(0x2222) });
274
275 EXPECT_NE(public_logs1, public_logs2);
276}
277
278TEST(PublicLogsTest, EqualityOperatorDifferentPayload)
279{
280 PublicLogs public_logs1;
281 public_logs1.add_log(PublicLog{ { FF(1) }, FF(0x1111) });
282
283 PublicLogs public_logs2;
284 public_logs2.add_log(PublicLog{ { FF(2) }, FF(0x1111) });
285
286 EXPECT_NE(public_logs1, public_logs2);
287}
288
289TEST(PublicLogsTest, EqualityOperatorDifferentContractAddress)
290{
291 PublicLogs public_logs1;
292 public_logs1.add_log(PublicLog{ { FF(1) }, FF(0x1111) });
293
294 PublicLogs public_logs2;
295 public_logs2.add_log(PublicLog{ { FF(1) }, FF(0x2222) });
296
297 EXPECT_NE(public_logs1, public_logs2);
298}
299
300TEST(PublicLogsTest, LargeLog)
301{
302 std::vector<FF> large_fields;
303 for (uint32_t i = 0; i < 100; ++i) {
304 large_fields.push_back(FF(i));
305 }
306
307 AztecAddress contract_address = FF(0xffff);
308 PublicLog large_log{ large_fields, contract_address };
309
310 PublicLogs public_logs;
311 public_logs.add_log(large_log);
312
313 EXPECT_EQ(public_logs.length, large_fields.size() + PUBLIC_LOG_HEADER_LENGTH);
314 EXPECT_EQ(public_logs.payload[0], FF(large_fields.size()));
315 EXPECT_EQ(public_logs.payload[1], contract_address);
316
317 for (size_t i = 0; i < large_fields.size(); ++i) {
318 EXPECT_EQ(public_logs.payload[PUBLIC_LOG_HEADER_LENGTH + i], FF(i));
319 }
320
321 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
322 ASSERT_EQ(recovered_logs.size(), 1);
323 EXPECT_EQ(recovered_logs[0].fields.size(), large_fields.size());
324 for (size_t i = 0; i < large_fields.size(); ++i) {
325 EXPECT_EQ(recovered_logs[0].fields[i], FF(i));
326 }
327}
328
329TEST(PublicLogsTest, ManySmallLogs)
330{
331 PublicLogs public_logs;
332 const uint32_t num_logs = 50;
333
334 for (uint32_t i = 0; i < num_logs; ++i) {
335 AztecAddress contract_address = FF(i);
336 PublicLog log{ { FF(i * 10), FF(i * 10 + 1) }, contract_address };
337 public_logs.add_log(log);
338 }
339
340 std::vector<PublicLog> recovered_logs = public_logs.to_logs();
341 ASSERT_EQ(recovered_logs.size(), num_logs);
342
343 for (uint32_t i = 0; i < num_logs; ++i) {
344 EXPECT_EQ(recovered_logs[i].contract_address, FF(i));
345 EXPECT_THAT(recovered_logs[i].fields, ElementsAre(FF(i * 10), FF(i * 10 + 1)));
346 }
347}
348
349} // namespace
350} // namespace bb::avm2
FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH
#define FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH
Definition aztec_constants.hpp:31
PUBLIC_LOG_HEADER_LENGTH
#define PUBLIC_LOG_HEADER_LENGTH
Definition aztec_constants.hpp:33
aztec_types.hpp
contract_address
AztecAddress contract_address
Definition written_public_data_slots_tree_check.test.cpp:97
length
uint8_t const size_t length
Definition data_store.hpp:9
bb::avm2::FF
AvmFlavorSettings::FF FF
Definition field.hpp:10
bb::TEST
TEST(BoomerangMegaCircuitBuilder, BasicCircuit)
Definition graph_description_megacircuitbuilder.test.cpp:22
std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13
bb::avm2::PublicLogs::from_logs
static PublicLogs from_logs(const std::vector< PublicLog > &logs)
Definition aztec_types.hpp:267