@aztec/protocol-contracts 0.81.0 → 0.82.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. package/artifacts/AuthRegistry.json +874 -874
  2. package/artifacts/ContractClassRegisterer.json +1331 -1314
  3. package/artifacts/ContractInstanceDeployer.json +870 -870
  4. package/artifacts/FeeJuice.json +1040 -1040
  5. package/artifacts/MultiCallEntrypoint.json +375 -345
  6. package/artifacts/Router.json +852 -852
  7. package/dest/protocol_contract_data.js +7 -7
  8. package/package.json +4 -4
  9. package/src/protocol_contract_data.ts +7 -7
package/artifacts/AuthRegistry.json CHANGED
@@ -11,32 +11,12 @@
11
11
  "internal"
12
12
  ],
13
13
  "abi": {
14
- "error_types": {
15
- "16761564377371454734": {
16
- "error_kind": "string",
17
- "string": "Array index out of bounds"
18
- },
19
- "17843811134343075018": {
20
- "error_kind": "string",
21
- "string": "Stack too deep"
22
- },
23
- "206160798890201757": {
24
- "error_kind": "string",
25
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
26
- },
27
- "5019202896831570965": {
28
- "error_kind": "string",
29
- "string": "attempt to add with overflow"
30
- },
31
- "6304245522015439386": {
32
- "error_kind": "string",
33
- "string": "Function _set_authorized can only be called internally"
34
- }
35
- },
36
14
  "parameters": [
37
15
  {
38
16
  "name": "approver",
39
17
  "type": {
18
+ "kind": "struct",
19
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
40
20
  "fields": [
41
21
  {
42
22
  "name": "inner",
@@ -44,9 +24,7 @@
44
24
  "kind": "field"
45
25
  }
46
26
  }
47
- ],
48
- "kind": "struct",
49
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
27
+ ]
50
28
  },
51
29
  "visibility": "private"
52
30
  },
@@ -65,23 +43,165 @@
65
43
  "visibility": "private"
66
44
  }
67
45
  ],
68
- "return_type": null
46
+ "return_type": null,
47
+ "error_types": {
48
+ "206160798890201757": {
49
+ "error_kind": "string",
50
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
51
+ },
52
+ "5019202896831570965": {
53
+ "error_kind": "string",
54
+ "string": "attempt to add with overflow"
55
+ },
56
+ "6304245522015439386": {
57
+ "error_kind": "string",
58
+ "string": "Function _set_authorized can only be called internally"
59
+ },
60
+ "16761564377371454734": {
61
+ "error_kind": "string",
62
+ "string": "Array index out of bounds"
63
+ },
64
+ "17843811134343075018": {
65
+ "error_kind": "string",
66
+ "string": "Stack too deep"
67
+ }
68
+ }
69
69
  },
70
- "bytecode": "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",
71
- "debug_symbols": "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",
70
+ "bytecode": "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",
71
+ "debug_symbols": "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",
72
72
  "brillig_names": [
73
73
  "_set_authorized"
74
74
  ]
75
75
  },
76
76
  {
77
- "name": "is_consumable",
77
+ "name": "sync_notes",
78
+ "is_unconstrained": true,
79
+ "custom_attributes": [],
80
+ "abi": {
81
+ "parameters": [],
82
+ "return_type": null,
83
+ "error_types": {
84
+ "2920182694213909827": {
85
+ "error_kind": "string",
86
+ "string": "attempt to subtract with overflow"
87
+ },
88
+ "3305101268118424981": {
89
+ "error_kind": "string",
90
+ "string": "Attempted to delete past the length of a CapsuleArray"
91
+ },
92
+ "3367683922240523006": {
93
+ "error_kind": "fmtstring",
94
+ "length": 58,
95
+ "item_types": [
96
+ {
97
+ "kind": "field"
98
+ }
99
+ ]
100
+ },
101
+ "5019202896831570965": {
102
+ "error_kind": "string",
103
+ "string": "attempt to add with overflow"
104
+ },
105
+ "5727012404371710682": {
106
+ "error_kind": "string",
107
+ "string": "push out of bounds"
108
+ },
109
+ "6753155520859132764": {
110
+ "error_kind": "string",
111
+ "string": "Failed to deliver note"
112
+ },
113
+ "8830323656616886390": {
114
+ "error_kind": "string",
115
+ "string": "Got a public log emitted by a different contract"
116
+ },
117
+ "13649294680379557736": {
118
+ "error_kind": "string",
119
+ "string": "extend_from_bounded_vec out of bounds"
120
+ },
121
+ "14657895983200220173": {
122
+ "error_kind": "string",
123
+ "string": "Attempted to read past the length of a CapsuleArray"
124
+ },
125
+ "16761564377371454734": {
126
+ "error_kind": "string",
127
+ "string": "Array index out of bounds"
128
+ },
129
+ "16775516380094354375": {
130
+ "error_kind": "fmtstring",
131
+ "length": 40,
132
+ "item_types": []
133
+ },
134
+ "16954218183513903507": {
135
+ "error_kind": "string",
136
+ "string": "Attempted to read past end of BoundedVec"
137
+ },
138
+ "17843811134343075018": {
139
+ "error_kind": "string",
140
+ "string": "Stack too deep"
141
+ }
142
+ }
143
+ },
144
+ "bytecode": "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",
145
+ "debug_symbols": "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",
146
+ "brillig_names": [
147
+ "sync_notes"
148
+ ]
149
+ },
150
+ {
151
+ "name": "public_dispatch",
78
152
  "is_unconstrained": true,
79
153
  "custom_attributes": [
80
- "public",
81
- "view"
154
+ "public"
82
155
  ],
83
156
  "abi": {
157
+ "parameters": [
158
+ {
159
+ "name": "selector",
160
+ "type": {
161
+ "kind": "field"
162
+ },
163
+ "visibility": "private"
164
+ }
165
+ ],
166
+ "return_type": null,
84
167
  "error_types": {
168
+ "206160798890201757": {
169
+ "error_kind": "string",
170
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
171
+ },
172
+ "715723737710351018": {
173
+ "error_kind": "string",
174
+ "string": "rejecting all"
175
+ },
176
+ "2830029349304997821": {
177
+ "error_kind": "fmtstring",
178
+ "length": 27,
179
+ "item_types": [
180
+ {
181
+ "kind": "field"
182
+ }
183
+ ]
184
+ },
185
+ "5019202896831570965": {
186
+ "error_kind": "string",
187
+ "string": "attempt to add with overflow"
188
+ },
189
+ "5444967152290923376": {
190
+ "error_kind": "string",
191
+ "string": "Function is_consumable can only be called statically"
192
+ },
193
+ "6304245522015439386": {
194
+ "error_kind": "string",
195
+ "string": "Function _set_authorized can only be called internally"
196
+ },
197
+ "9474245853673257536": {
198
+ "error_kind": "string",
199
+ "string": "Function is_reject_all can only be called statically"
200
+ },
201
+ "12737498021964987455": {
202
+ "error_kind": "string",
203
+ "string": "unauthorized"
204
+ },
85
205
  "16761564377371454734": {
86
206
  "error_kind": "string",
87
207
  "string": "Array index out of bounds"
@@ -89,7 +209,40 @@
89
209
  "17843811134343075018": {
90
210
  "error_kind": "string",
91
211
  "string": "Stack too deep"
212
+ }
213
+ }
214
+ },
215
+ "bytecode": "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",
216
+ "debug_symbols": "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",
217
+ "brillig_names": [
218
+ "public_dispatch"
219
+ ]
220
+ },
221
+ {
222
+ "name": "set_authorized",
223
+ "is_unconstrained": true,
224
+ "custom_attributes": [
225
+ "public"
226
+ ],
227
+ "abi": {
228
+ "parameters": [
229
+ {
230
+ "name": "message_hash",
231
+ "type": {
232
+ "kind": "field"
233
+ },
234
+ "visibility": "private"
92
235
  },
236
+ {
237
+ "name": "authorize",
238
+ "type": {
239
+ "kind": "boolean"
240
+ },
241
+ "visibility": "private"
242
+ }
243
+ ],
244
+ "return_type": null,
245
+ "error_types": {
93
246
  "206160798890201757": {
94
247
  "error_kind": "string",
95
248
  "string": "Storage slot 0 not allowed. Storage slots must start from 1."
@@ -98,15 +251,33 @@
98
251
  "error_kind": "string",
99
252
  "string": "attempt to add with overflow"
100
253
  },
101
- "5444967152290923376": {
254
+ "16761564377371454734": {
102
255
  "error_kind": "string",
103
- "string": "Function is_consumable can only be called statically"
256
+ "string": "Array index out of bounds"
257
+ },
258
+ "17843811134343075018": {
259
+ "error_kind": "string",
260
+ "string": "Stack too deep"
104
261
  }
105
- },
262
+ }
263
+ },
264
+ "bytecode": "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",
265
+ "debug_symbols": "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",
266
+ "brillig_names": [
267
+ "set_authorized"
268
+ ]
269
+ },
270
+ {
271
+ "name": "unconstrained_is_consumable",
272
+ "is_unconstrained": true,
273
+ "custom_attributes": [],
274
+ "abi": {
106
275
  "parameters": [
107
276
  {
108
277
  "name": "on_behalf_of",
109
278
  "type": {
279
+ "kind": "struct",
280
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
110
281
  "fields": [
111
282
  {
112
283
  "name": "inner",
@@ -114,9 +285,7 @@
114
285
  "kind": "field"
115
286
  }
116
287
  }
117
- ],
118
- "kind": "struct",
119
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
288
+ ]
120
289
  },
121
290
  "visibility": "private"
122
291
  },
@@ -133,51 +302,308 @@
133
302
  "kind": "boolean"
134
303
  },
135
304
  "visibility": "public"
136
- }
137
- },
138
- "bytecode": "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",
139
- "debug_symbols": "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",
140
- "brillig_names": [
141
- "is_consumable"
142
- ]
143
- },
144
- {
145
- "name": "set_authorized_private",
146
- "is_unconstrained": false,
147
- "custom_attributes": [
148
- "private"
149
- ],
150
- "abi": {
305
+ },
151
306
  "error_types": {
152
- "16761564377371454734": {
307
+ "206160798890201757": {
153
308
  "error_kind": "string",
154
- "string": "Array index out of bounds"
309
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
155
310
  },
156
- "17843811134343075018": {
311
+ "5019202896831570965": {
157
312
  "error_kind": "string",
158
- "string": "Stack too deep"
313
+ "string": "attempt to add with overflow"
159
314
  },
160
- "4939791462094160055": {
315
+ "16761564377371454734": {
161
316
  "error_kind": "string",
162
- "string": "Message not authorized by account"
317
+ "string": "Array index out of bounds"
163
318
  },
164
- "5019202896831570965": {
319
+ "17843811134343075018": {
165
320
  "error_kind": "string",
166
- "string": "attempt to add with overflow"
321
+ "string": "Stack too deep"
167
322
  }
168
- },
169
- "parameters": [
170
- {
171
- "name": "inputs",
172
- "type": {
173
- "fields": [
174
- {
175
- "name": "call_context",
176
- "type": {
177
- "fields": [
178
- {
179
- "name": "msg_sender",
323
+ }
324
+ },
325
+ "bytecode": "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",
326
+ "debug_symbols": "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",
327
+ "brillig_names": [
328
+ "unconstrained_is_consumable"
329
+ ]
330
+ },
331
+ {
332
+ "name": "consume",
333
+ "is_unconstrained": true,
334
+ "custom_attributes": [
335
+ "public"
336
+ ],
337
+ "abi": {
338
+ "parameters": [
339
+ {
340
+ "name": "on_behalf_of",
341
+ "type": {
342
+ "kind": "struct",
343
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
344
+ "fields": [
345
+ {
346
+ "name": "inner",
347
+ "type": {
348
+ "kind": "field"
349
+ }
350
+ }
351
+ ]
352
+ },
353
+ "visibility": "private"
354
+ },
355
+ {
356
+ "name": "inner_hash",
357
+ "type": {
358
+ "kind": "field"
359
+ },
360
+ "visibility": "private"
361
+ }
362
+ ],
363
+ "return_type": {
364
+ "abi_type": {
365
+ "kind": "field"
366
+ },
367
+ "visibility": "public"
368
+ },
369
+ "error_types": {
370
+ "206160798890201757": {
371
+ "error_kind": "string",
372
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
373
+ },
374
+ "715723737710351018": {
375
+ "error_kind": "string",
376
+ "string": "rejecting all"
377
+ },
378
+ "5019202896831570965": {
379
+ "error_kind": "string",
380
+ "string": "attempt to add with overflow"
381
+ },
382
+ "12737498021964987455": {
383
+ "error_kind": "string",
384
+ "string": "unauthorized"
385
+ },
386
+ "16761564377371454734": {
387
+ "error_kind": "string",
388
+ "string": "Array index out of bounds"
389
+ },
390
+ "17843811134343075018": {
391
+ "error_kind": "string",
392
+ "string": "Stack too deep"
393
+ }
394
+ }
395
+ },
396
+ "bytecode": "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",
397
+ "debug_symbols": "7d3bbtw4Egbgd/F1Lng+5FUGiyDJeAIDhh04yQKLIO++smOpO+ZPlbvQ65aW/81gvVGZpc9sFsnW4efV39effnz5cHP3z/23q/d//by6vf/88fvN/d30089f764+Pdzc3t58+XD8f1+Zx/9YX54Cvn39ePf487fvHx++X73P2dV3V9d3f1+9LybW6Vf8c3N7ffXeuvDrX++ubHCqqKyJil4VpWorqc4rqQyzqq2sOq+iaqskFOVMjc9Rztq0RMXw611zsDXJPx9srfWHJlJER5c0H1zLcqy35SmdareVTtxSOs6YbaWzLR27LR27MZ26qXSc31Y6ZVPpePfW6cQ5HWfcH+m0x+Ya5jRyrYff7IoFR/vlNwdnDseilKc+GuYsnHXHBz+iRE+UFqUQpUFJ/PgAlESUBiVborQo7CktSjFEaVECUVoUluQWpbIkAxQOtA2KNxxoAUokSotSidKgWK6SAQpLcoviWJIBCktyi+K5SgYoLMkAhSW5RQmBKC0KS3KLElmSAUomSoOSWJIBCktyi5K5n9Ki1DFRnD+ghPgCJZgxS3K28xVyLnv/EmXQ/RQBZcySvI7ixizJAsqYJVlAGXOVvI7iOdACFJbkFiWwpwAUluQWJZ6hJNtSZpTjOTNGiTHPR6dytOywLiOWlGeVEg7HZv87+brj5FPecfI57jj5V1yo5qOUvK/LQJD+bAKkE9OcfI7lcIsRPtgfkg8mrR885ZHMkog/Gjjmc01vfq5xOddkwnr6MbvnY49ZvE9Pub/iVqft5r5f92g67svndco9H+f+FFQVQb1V8mpQ51t55zLauYG0odi5hVCc8Bkrcam2JWb74hMWHT4Hl+ySTs7r6cTs59xjDllIJy37diXbJp3OjTGuzhMX500R0qlmzj1Wa4R08kEnZ9ekg3VsWT4HXvpjOZMPO5Wm+kMbMaGEpgIyJzQdLsykpmKQDz3hcK4+/s4f3+O7o/zTvvPvzE/3k//O/dPO/dPO/TvfTe0n/7Dz/Ou+8y9+5/mXfedfdz5/qPuevyWz7/qVzL7rV7JvX7+cPeQfnZD/hS6vSN7SBbokuiCXwM8Rdgl0gS6VLsglsr9gl0IX5JIcXaAL6zR0yazT2IXjLnbhuAtdLrBvtQ+XTBfkUrmexi6s08glG9Zp7MI6jV24noYulnUau7BOQxfH9TR2YZ2GLp51GrtEukAX1mnoElinsQv3X6BLGtZl9QkAuQxbp1fvI8vj7r8ILsPWacFl2Dq96lLMsHVacBl2Pb3uYjnuYhfWaeji2F+wC+s0dsF12ufldsJgzLrLGV/7VTqPQLlYOmVT6YRt6YRt6cRt6XQe2nmpdDo3+l0snbSpdDqXdf0P09n+IyJL5yEgg6NUojQoxROlRSlEaVAqewpAyUR5iVKNJUqLwpIMUFiSWxTLgRagcKBtUTqXbA2OkojSoHiukgEKSzJAYUluUQJLMkDhKrlFiSzJAIUluUVJXCUDFJZkgMKS3KJ0blsfHIUluUUpLMkAhfspDYo1ZsyusnphvTVuzM2D1cuvJpUxpyqSyphzFUHFj7l/IKmMWYMElTDmulBS4WgLVCIrM1JhX0EqrMxAJZ2hMmtflxan7xUOR8PXpaU6Z5+P3tr2+Jufss9219nXPWd/jhX05bKv8krX5rOOBmtXcU/5pE3lY19xDdvb5rMxH7sxH7sxn1fsmbxtPmFj+dRt5fOKFfqZ89nBfqh9xV10A6oERxWgkqjSqkRLFaDCvgJUkqEKUAlUASqszEAlszIjFY62QKVwtEUqkSpApVKlValcMyMVVuZWxRlWZqTCygxULNfMSIWVGamwMgOVt9/t34UKKzNQ8azMSCVTpVUJrMxIhZUZqETurwCVNGZfWb/DxJUxdxLWr010Zcz5iqBSx5yvSCpj7iSsq3gzZg2SVAJVgApHW6BiWZmRCvsKUHGszEjlDJVZe59AKkdLEHyfQE55ZinhcGz2v7P3Yc/Zn+NKzctlf44V9AWzl1e6PknZ+7qMBunPNkA+Mc3Z51jqcjQ+2B+yDyatHzzlkcySiD8aPeaTfcXDnM59snE52WTCev4xu+djj138lNHv5NOOk897lu9cmRXiUlFC/uPdRk9RJaii8Ddl0cwZuujq/191Xt+P8zVQBagUqjQqoXMNy+gqmSqtimVfQSqJKq1K517R0VVYmZEKKzNQ8RxtkQpHW6DSuYZldJVIFaDCNTNQiazMSIWVGagkVmakwjUzUMmszEiFlRmoFK6ZkQorM1JhZQYqnbt3R1dhZW5VomFlRircXwEqbsy+sn6HQ/Rj7iSsXxsXQ6AKUBlzviKoxDF3EiSVMWuQoJLGXB1KKhxtkQorM1DJ7CtIhZUZqJQzVOaLvQkhVrPr7MuOs0/nWEFfLnsrr3RDOutosPoM+2TjtvJ5xXVtb5vPxnz8xnz81nzqtvIJfmP5lG3l84oV+pnz2cF+aIqZKq1KslQBKpEqrUo2VAEq7CtIpVKlVSmeKkCFlRmoVFZmpMLRFqlwtG1VsglUASqFKq2K5ZoZqbAyAxXHyoxUWJmBiueaGamwMiMVVmagErhmRiqszEAlsjIjlUSVViWxMiMVVmakwv0VoFLG7Cvrd5gUM+ZOwvq1icWMOV8RVOyY8xVJZcydBEllzBokqLgxV4eSCkdboOJZmZEK+wpQCazMSOUMlflib0Io0e85+3NcqXnB7Oues3/FXXhJyt67ZTTwof7RRnv0tIqcX3RRTDhkj9+EUJZfnadU1w+2NqTDWxaiNceHP55sNWNujHmzZOFteDn0VTPmokRQsewrSGXML/IElUGXapIK+wpQ8ewrSGXMpZqry/l502y41zDmsl5SGfNLX0EljjlfkVQCVYDKmJVZUEkcbZEKR1ugksfcRJVU2FeAShlzf2VVxRk75kPnV9dBU2JjPlZQUmFfASp+zMerSypjPkBPUAnsK0iFfQWoDPoYZGG+Esd8bYOgkgZ9FL+gMuZ8RVIZ8zHIgkoeszJLKhxtgUrhaItUxnxBgaBS2VdaFWvG3F8RVDqPcvB5PlEXbB5tHWQ7DyseXCWwryCVQpVWpXNZ+ugq7CtAJbGvIJU8pIowX8mOKkAlUaVVKWPOVySVQBWgMmZlFlQqR1ukwtG2VXGd13iPrsK+AlTsmPsrgkqQVYwZbR3koqEKUGFfASqv2EkYUaVQpVXJ7CtIhX0FqBQ3pIowXymZKq1KtVQBKmPOVySVSpVGxZsxK7OkwtEWqFiOtkglUaVVcewrQMWPub8iqHRepGBLXKKOntYHVZzJh0fNm+oP5xoTOLxMu6LPRxcXnXCql1oK+c4NDoTJ7DEdmEIYCNN5cTJhCnsMhqnsMR2YPCrM+jwmdF7cQpjOF/OEscPOYySYQBgMM2y5FmAcB98ODAdfDOMtYTAMewyGCcPuxwgwGcOYusBYO9rTtl3o3BMxugr7ClDp7DaMrlKo0qhEw76CVNhXgIp1Q6qsz1eizVRpVTrf2Y+uMuZ8RVKpVGlV/JiVWVLhaAtUAkdbpJKo0qpE9hWgksbcX1lXSfgtidHNDUSX25h8egx+GboQo2gnKNoJinbwZ0yIUbSTFOeD7ypcj8mKfpDhrG76oM0xyTYx+MoqIaacHoOfjxGX3fR09I7mJSadHJPxsxWEGEU7VtGOVbSD33UixCja8Yrz6YwHqzHBKWLK6TH4qXrrMZ2rDLOdX5g9nbJvo6CCTYfSlErzecj4Li8hquC9QzGqaKLw3pPNeR6C7HQSbVTWROG9CzEqqqKqJgqvDcUolUZQyQdVW1ElH1XyUSWfVPJJpZFVGlmlgZ9Tbqud54e2OhBVFVGdN/FZs4xs00y6tFFRFYUztP4wVY/NaFM7o6gQ1RlFV6O8wc+3FqMCjkpxiSqlieqMUcHMk6Xpf7ZtdcYoIaozRklRWROF9z9sdIthjKaNSpqoqGqrM9oIUSloovAdLWJU1kThJyyIUUUThb/XFqM0bVnTOa+8jGyxuibKGlVU1EQ5r4oqmiiv0vBJExVUhgF/vvyhEnnfjBsWv2tajCqaKLxWF6OSJqozAkhRKo2ski+qtopKvqrkq0bedaq5D3mJSqaNSpoo61VRRRPlgiqqaqI6cwAhqjMHWJ85dJ7dJ0ZpZkSdZ79JUXhmnv087c3h5S6A97h61TB33RpjG5NOj8H1TogJiphy+tzf+06FlKKyJqpTIaUoVVtB1VZQtRVVbUVVW0n190qqtrLqvPDz2qUofO2uGBVUUapPCp5Zr48x+NbNauY9zeqamKAYlwL+FK+34xS54T1nISYqYurpBiEoYhTt4M/tekxS/E2Top2saAd/Xmuc+3XNzUoi4HorxCjaqUERU0+OiSYoYhTt4Nno0d8HxZST/6bReUWMoh1/+nyocx2OEHP6ZyHGoIg5fTyI+KEx6zHZKGI07SjOpyj6TlH8feqJ/eDX9NO/Pz7cfPx0e/1tinj8xx93n7/f3N89//j9P1/nf/n0cHN7e/Plw9eH+8/Xf/94uP5we//58d+uzPN//squvsvRTLk8zdCji++if/rxMbFYpx9rnlqdWv4v",
398
+ "brillig_names": [
399
+ "consume"
400
+ ]
401
+ },
402
+ {
403
+ "name": "process_log",
404
+ "is_unconstrained": true,
405
+ "custom_attributes": [],
406
+ "abi": {
407
+ "parameters": [
408
+ {
409
+ "name": "_log_ciphertext",
410
+ "type": {
411
+ "kind": "struct",
412
+ "path": "std::collections::bounded_vec::BoundedVec",
413
+ "fields": [
414
+ {
415
+ "name": "storage",
416
+ "type": {
417
+ "kind": "array",
418
+ "length": 18,
419
+ "type": {
420
+ "kind": "field"
421
+ }
422
+ }
423
+ },
424
+ {
425
+ "name": "len",
426
+ "type": {
427
+ "kind": "integer",
428
+ "sign": "unsigned",
429
+ "width": 32
430
+ }
431
+ }
432
+ ]
433
+ },
434
+ "visibility": "private"
435
+ },
436
+ {
437
+ "name": "_tx_hash",
438
+ "type": {
439
+ "kind": "field"
440
+ },
441
+ "visibility": "private"
442
+ },
443
+ {
444
+ "name": "_unique_note_hashes_in_tx",
445
+ "type": {
446
+ "kind": "struct",
447
+ "path": "std::collections::bounded_vec::BoundedVec",
448
+ "fields": [
449
+ {
450
+ "name": "storage",
451
+ "type": {
452
+ "kind": "array",
453
+ "length": 64,
454
+ "type": {
455
+ "kind": "field"
456
+ }
457
+ }
458
+ },
459
+ {
460
+ "name": "len",
461
+ "type": {
462
+ "kind": "integer",
463
+ "sign": "unsigned",
464
+ "width": 32
465
+ }
466
+ }
467
+ ]
468
+ },
469
+ "visibility": "private"
470
+ },
471
+ {
472
+ "name": "_first_nullifier_in_tx",
473
+ "type": {
474
+ "kind": "field"
475
+ },
476
+ "visibility": "private"
477
+ },
478
+ {
479
+ "name": "_recipient",
480
+ "type": {
481
+ "kind": "struct",
482
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
483
+ "fields": [
484
+ {
485
+ "name": "inner",
486
+ "type": {
487
+ "kind": "field"
488
+ }
489
+ }
490
+ ]
491
+ },
492
+ "visibility": "private"
493
+ }
494
+ ],
495
+ "return_type": null,
496
+ "error_types": {
497
+ "16775516380094354375": {
498
+ "error_kind": "fmtstring",
499
+ "length": 40,
500
+ "item_types": []
501
+ },
502
+ "17843811134343075018": {
503
+ "error_kind": "string",
504
+ "string": "Stack too deep"
505
+ }
506
+ }
507
+ },
508
+ "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
509
+ "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiT0xv/mSe7DRJ/JkrYbTwBCAyo04AwG6AINEGiARANOaECJBig0AG2yRpus0SZrtMmENpnQJhPaZEKbTGiTCW0yoU0mtMkENXlL6WGiM7W3e8PpltAcCs/8HO1P9xnj0Nh2iTa3oG8Byq+xlFzJfO1sr6gKLiqVIAn0Ag==",
510
+ "brillig_names": [
511
+ "process_log"
512
+ ]
513
+ },
514
+ {
515
+ "name": "is_consumable",
516
+ "is_unconstrained": true,
517
+ "custom_attributes": [
518
+ "public",
519
+ "view"
520
+ ],
521
+ "abi": {
522
+ "parameters": [
523
+ {
524
+ "name": "on_behalf_of",
525
+ "type": {
526
+ "kind": "struct",
527
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
528
+ "fields": [
529
+ {
530
+ "name": "inner",
531
+ "type": {
532
+ "kind": "field"
533
+ }
534
+ }
535
+ ]
536
+ },
537
+ "visibility": "private"
538
+ },
539
+ {
540
+ "name": "message_hash",
541
+ "type": {
542
+ "kind": "field"
543
+ },
544
+ "visibility": "private"
545
+ }
546
+ ],
547
+ "return_type": {
548
+ "abi_type": {
549
+ "kind": "boolean"
550
+ },
551
+ "visibility": "public"
552
+ },
553
+ "error_types": {
554
+ "206160798890201757": {
555
+ "error_kind": "string",
556
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
557
+ },
558
+ "5019202896831570965": {
559
+ "error_kind": "string",
560
+ "string": "attempt to add with overflow"
561
+ },
562
+ "5444967152290923376": {
563
+ "error_kind": "string",
564
+ "string": "Function is_consumable can only be called statically"
565
+ },
566
+ "16761564377371454734": {
567
+ "error_kind": "string",
568
+ "string": "Array index out of bounds"
569
+ },
570
+ "17843811134343075018": {
571
+ "error_kind": "string",
572
+ "string": "Stack too deep"
573
+ }
574
+ }
575
+ },
576
+ "bytecode": "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",
577
+ "debug_symbols": "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",
578
+ "brillig_names": [
579
+ "is_consumable"
580
+ ]
581
+ },
582
+ {
583
+ "name": "set_authorized_private",
584
+ "is_unconstrained": false,
585
+ "custom_attributes": [
586
+ "private"
587
+ ],
588
+ "abi": {
589
+ "parameters": [
590
+ {
591
+ "name": "inputs",
592
+ "type": {
593
+ "kind": "struct",
594
+ "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs",
595
+ "fields": [
596
+ {
597
+ "name": "call_context",
598
+ "type": {
599
+ "kind": "struct",
600
+ "path": "authwit::aztec::protocol_types::abis::call_context::CallContext",
601
+ "fields": [
602
+ {
603
+ "name": "msg_sender",
180
604
  "type": {
605
+ "kind": "struct",
606
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
181
607
  "fields": [
182
608
  {
183
609
  "name": "inner",
@@ -185,14 +611,14 @@
185
611
  "kind": "field"
186
612
  }
187
613
  }
188
- ],
189
- "kind": "struct",
190
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
614
+ ]
191
615
  }
192
616
  },
193
617
  {
194
618
  "name": "contract_address",
195
619
  "type": {
620
+ "kind": "struct",
621
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
196
622
  "fields": [
197
623
  {
198
624
  "name": "inner",
@@ -200,14 +626,14 @@
200
626
  "kind": "field"
201
627
  }
202
628
  }
203
- ],
204
- "kind": "struct",
205
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
629
+ ]
206
630
  }
207
631
  },
208
632
  {
209
633
  "name": "function_selector",
210
634
  "type": {
635
+ "kind": "struct",
636
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
211
637
  "fields": [
212
638
  {
213
639
  "name": "inner",
@@ -217,9 +643,7 @@
217
643
  "width": 32
218
644
  }
219
645
  }
220
- ],
221
- "kind": "struct",
222
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
646
+ ]
223
647
  }
224
648
  },
225
649
  {
@@ -228,18 +652,20 @@
228
652
  "kind": "boolean"
229
653
  }
230
654
  }
231
- ],
232
- "kind": "struct",
233
- "path": "authwit::aztec::protocol_types::abis::call_context::CallContext"
655
+ ]
234
656
  }
235
657
  },
236
658
  {
237
659
  "name": "historical_header",
238
660
  "type": {
661
+ "kind": "struct",
662
+ "path": "authwit::aztec::protocol_types::block_header::BlockHeader",
239
663
  "fields": [
240
664
  {
241
665
  "name": "last_archive",
242
666
  "type": {
667
+ "kind": "struct",
668
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
243
669
  "fields": [
244
670
  {
245
671
  "name": "root",
@@ -255,14 +681,14 @@
255
681
  "width": 32
256
682
  }
257
683
  }
258
- ],
259
- "kind": "struct",
260
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
684
+ ]
261
685
  }
262
686
  },
263
687
  {
264
688
  "name": "content_commitment",
265
689
  "type": {
690
+ "kind": "struct",
691
+ "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment",
266
692
  "fields": [
267
693
  {
268
694
  "name": "num_txs",
@@ -288,18 +714,20 @@
288
714
  "kind": "field"
289
715
  }
290
716
  }
291
- ],
292
- "kind": "struct",
293
- "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment"
717
+ ]
294
718
  }
295
719
  },
296
720
  {
297
721
  "name": "state",
298
722
  "type": {
723
+ "kind": "struct",
724
+ "path": "authwit::aztec::protocol_types::state_reference::StateReference",
299
725
  "fields": [
300
726
  {
301
727
  "name": "l1_to_l2_message_tree",
302
728
  "type": {
729
+ "kind": "struct",
730
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
303
731
  "fields": [
304
732
  {
305
733
  "name": "root",
@@ -315,18 +743,20 @@
315
743
  "width": 32
316
744
  }
317
745
  }
318
- ],
319
- "kind": "struct",
320
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
746
+ ]
321
747
  }
322
748
  },
323
749
  {
324
750
  "name": "partial",
325
751
  "type": {
752
+ "kind": "struct",
753
+ "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference",
326
754
  "fields": [
327
755
  {
328
756
  "name": "note_hash_tree",
329
757
  "type": {
758
+ "kind": "struct",
759
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
330
760
  "fields": [
331
761
  {
332
762
  "name": "root",
@@ -342,14 +772,14 @@
342
772
  "width": 32
343
773
  }
344
774
  }
345
- ],
346
- "kind": "struct",
347
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
775
+ ]
348
776
  }
349
777
  },
350
778
  {
351
779
  "name": "nullifier_tree",
352
780
  "type": {
781
+ "kind": "struct",
782
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
353
783
  "fields": [
354
784
  {
355
785
  "name": "root",
@@ -365,14 +795,14 @@
365
795
  "width": 32
366
796
  }
367
797
  }
368
- ],
369
- "kind": "struct",
370
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
798
+ ]
371
799
  }
372
800
  },
373
801
  {
374
802
  "name": "public_data_tree",
375
803
  "type": {
804
+ "kind": "struct",
805
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
376
806
  "fields": [
377
807
  {
378
808
  "name": "root",
@@ -388,24 +818,20 @@
388
818
  "width": 32
389
819
  }
390
820
  }
391
- ],
392
- "kind": "struct",
393
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
821
+ ]
394
822
  }
395
823
  }
396
- ],
397
- "kind": "struct",
398
- "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference"
824
+ ]
399
825
  }
400
826
  }
401
- ],
402
- "kind": "struct",
403
- "path": "authwit::aztec::protocol_types::state_reference::StateReference"
827
+ ]
404
828
  }
405
829
  },
406
830
  {
407
831
  "name": "global_variables",
408
832
  "type": {
833
+ "kind": "struct",
834
+ "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables",
409
835
  "fields": [
410
836
  {
411
837
  "name": "chain_id",
@@ -442,6 +868,8 @@
442
868
  {
443
869
  "name": "coinbase",
444
870
  "type": {
871
+ "kind": "struct",
872
+ "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress",
445
873
  "fields": [
446
874
  {
447
875
  "name": "inner",
@@ -449,14 +877,14 @@
449
877
  "kind": "field"
450
878
  }
451
879
  }
452
- ],
453
- "kind": "struct",
454
- "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
880
+ ]
455
881
  }
456
882
  },
457
883
  {
458
884
  "name": "fee_recipient",
459
885
  "type": {
886
+ "kind": "struct",
887
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
460
888
  "fields": [
461
889
  {
462
890
  "name": "inner",
@@ -464,14 +892,14 @@
464
892
  "kind": "field"
465
893
  }
466
894
  }
467
- ],
468
- "kind": "struct",
469
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
895
+ ]
470
896
  }
471
897
  },
472
898
  {
473
899
  "name": "gas_fees",
474
900
  "type": {
901
+ "kind": "struct",
902
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
475
903
  "fields": [
476
904
  {
477
905
  "name": "fee_per_da_gas",
@@ -485,14 +913,10 @@
485
913
  "kind": "field"
486
914
  }
487
915
  }
488
- ],
489
- "kind": "struct",
490
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
916
+ ]
491
917
  }
492
918
  }
493
- ],
494
- "kind": "struct",
495
- "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables"
919
+ ]
496
920
  }
497
921
  },
498
922
  {
@@ -507,14 +931,14 @@
507
931
  "kind": "field"
508
932
  }
509
933
  }
510
- ],
511
- "kind": "struct",
512
- "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
934
+ ]
513
935
  }
514
936
  },
515
937
  {
516
938
  "name": "tx_context",
517
939
  "type": {
940
+ "kind": "struct",
941
+ "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext",
518
942
  "fields": [
519
943
  {
520
944
  "name": "chain_id",
@@ -531,10 +955,14 @@
531
955
  {
532
956
  "name": "gas_settings",
533
957
  "type": {
958
+ "kind": "struct",
959
+ "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings",
534
960
  "fields": [
535
961
  {
536
962
  "name": "gas_limits",
537
963
  "type": {
964
+ "kind": "struct",
965
+ "path": "authwit::aztec::protocol_types::abis::gas::Gas",
538
966
  "fields": [
539
967
  {
540
968
  "name": "da_gas",
@@ -552,14 +980,14 @@
552
980
  "width": 32
553
981
  }
554
982
  }
555
- ],
556
- "kind": "struct",
557
- "path": "authwit::aztec::protocol_types::abis::gas::Gas"
983
+ ]
558
984
  }
559
985
  },
560
986
  {
561
987
  "name": "teardown_gas_limits",
562
988
  "type": {
989
+ "kind": "struct",
990
+ "path": "authwit::aztec::protocol_types::abis::gas::Gas",
563
991
  "fields": [
564
992
  {
565
993
  "name": "da_gas",
@@ -577,14 +1005,14 @@
577
1005
  "width": 32
578
1006
  }
579
1007
  }
580
- ],
581
- "kind": "struct",
582
- "path": "authwit::aztec::protocol_types::abis::gas::Gas"
1008
+ ]
583
1009
  }
584
1010
  },
585
1011
  {
586
1012
  "name": "max_fees_per_gas",
587
1013
  "type": {
1014
+ "kind": "struct",
1015
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
588
1016
  "fields": [
589
1017
  {
590
1018
  "name": "fee_per_da_gas",
@@ -598,14 +1026,14 @@
598
1026
  "kind": "field"
599
1027
  }
600
1028
  }
601
- ],
602
- "kind": "struct",
603
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
1029
+ ]
604
1030
  }
605
1031
  },
606
1032
  {
607
1033
  "name": "max_priority_fees_per_gas",
608
1034
  "type": {
1035
+ "kind": "struct",
1036
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
609
1037
  "fields": [
610
1038
  {
611
1039
  "name": "fee_per_da_gas",
@@ -619,19 +1047,13 @@
619
1047
  "kind": "field"
620
1048
  }
621
1049
  }
622
- ],
623
- "kind": "struct",
624
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
1050
+ ]
625
1051
  }
626
1052
  }
627
- ],
628
- "kind": "struct",
629
- "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
1053
+ ]
630
1054
  }
631
1055
  }
632
- ],
633
- "kind": "struct",
634
- "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
1056
+ ]
635
1057
  }
636
1058
  },
637
1059
  {
@@ -642,15 +1064,15 @@
642
1064
  "width": 32
643
1065
  }
644
1066
  }
645
- ],
646
- "kind": "struct",
647
- "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs"
1067
+ ]
648
1068
  },
649
1069
  "visibility": "private"
650
1070
  },
651
1071
  {
652
1072
  "name": "approver",
653
1073
  "type": {
1074
+ "kind": "struct",
1075
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
654
1076
  "fields": [
655
1077
  {
656
1078
  "name": "inner",
@@ -658,9 +1080,7 @@
658
1080
  "kind": "field"
659
1081
  }
660
1082
  }
661
- ],
662
- "kind": "struct",
663
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1083
+ ]
664
1084
  },
665
1085
  "visibility": "private"
666
1086
  },
@@ -681,14 +1101,20 @@
681
1101
  ],
682
1102
  "return_type": {
683
1103
  "abi_type": {
1104
+ "kind": "struct",
1105
+ "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs",
684
1106
  "fields": [
685
1107
  {
686
1108
  "name": "call_context",
687
1109
  "type": {
1110
+ "kind": "struct",
1111
+ "path": "authwit::aztec::protocol_types::abis::call_context::CallContext",
688
1112
  "fields": [
689
1113
  {
690
1114
  "name": "msg_sender",
691
1115
  "type": {
1116
+ "kind": "struct",
1117
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
692
1118
  "fields": [
693
1119
  {
694
1120
  "name": "inner",
@@ -696,14 +1122,14 @@
696
1122
  "kind": "field"
697
1123
  }
698
1124
  }
699
- ],
700
- "kind": "struct",
701
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1125
+ ]
702
1126
  }
703
1127
  },
704
1128
  {
705
1129
  "name": "contract_address",
706
1130
  "type": {
1131
+ "kind": "struct",
1132
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
707
1133
  "fields": [
708
1134
  {
709
1135
  "name": "inner",
@@ -711,14 +1137,14 @@
711
1137
  "kind": "field"
712
1138
  }
713
1139
  }
714
- ],
715
- "kind": "struct",
716
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1140
+ ]
717
1141
  }
718
1142
  },
719
1143
  {
720
1144
  "name": "function_selector",
721
1145
  "type": {
1146
+ "kind": "struct",
1147
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
722
1148
  "fields": [
723
1149
  {
724
1150
  "name": "inner",
@@ -728,9 +1154,7 @@
728
1154
  "width": 32
729
1155
  }
730
1156
  }
731
- ],
732
- "kind": "struct",
733
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
1157
+ ]
734
1158
  }
735
1159
  },
736
1160
  {
@@ -739,9 +1163,7 @@
739
1163
  "kind": "boolean"
740
1164
  }
741
1165
  }
742
- ],
743
- "kind": "struct",
744
- "path": "authwit::aztec::protocol_types::abis::call_context::CallContext"
1166
+ ]
745
1167
  }
746
1168
  },
747
1169
  {
@@ -773,10 +1195,14 @@
773
1195
  {
774
1196
  "name": "max_block_number",
775
1197
  "type": {
1198
+ "kind": "struct",
1199
+ "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber",
776
1200
  "fields": [
777
1201
  {
778
1202
  "name": "_opt",
779
1203
  "type": {
1204
+ "kind": "struct",
1205
+ "path": "std::option::Option",
780
1206
  "fields": [
781
1207
  {
782
1208
  "name": "_is_some",
@@ -792,14 +1218,10 @@
792
1218
  "width": 32
793
1219
  }
794
1220
  }
795
- ],
796
- "kind": "struct",
797
- "path": "std::option::Option"
1221
+ ]
798
1222
  }
799
1223
  }
800
- ],
801
- "kind": "struct",
802
- "path": "authwit::aztec::protocol_types::abis::max_block_number::MaxBlockNumber"
1224
+ ]
803
1225
  }
804
1226
  },
805
1227
  {
@@ -808,6 +1230,8 @@
808
1230
  "kind": "array",
809
1231
  "length": 16,
810
1232
  "type": {
1233
+ "kind": "struct",
1234
+ "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest",
811
1235
  "fields": [
812
1236
  {
813
1237
  "name": "value",
@@ -823,9 +1247,7 @@
823
1247
  "width": 32
824
1248
  }
825
1249
  }
826
- ],
827
- "kind": "struct",
828
- "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest"
1250
+ ]
829
1251
  }
830
1252
  }
831
1253
  },
@@ -835,6 +1257,8 @@
835
1257
  "kind": "array",
836
1258
  "length": 16,
837
1259
  "type": {
1260
+ "kind": "struct",
1261
+ "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest",
838
1262
  "fields": [
839
1263
  {
840
1264
  "name": "value",
@@ -850,9 +1274,7 @@
850
1274
  "width": 32
851
1275
  }
852
1276
  }
853
- ],
854
- "kind": "struct",
855
- "path": "authwit::aztec::protocol_types::abis::read_request::ReadRequest"
1277
+ ]
856
1278
  }
857
1279
  }
858
1280
  },
@@ -862,14 +1284,20 @@
862
1284
  "kind": "array",
863
1285
  "length": 16,
864
1286
  "type": {
1287
+ "kind": "struct",
1288
+ "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator",
865
1289
  "fields": [
866
1290
  {
867
1291
  "name": "request",
868
1292
  "type": {
1293
+ "kind": "struct",
1294
+ "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest",
869
1295
  "fields": [
870
1296
  {
871
1297
  "name": "pk_m",
872
1298
  "type": {
1299
+ "kind": "struct",
1300
+ "path": "std::embedded_curve_ops::EmbeddedCurvePoint",
873
1301
  "fields": [
874
1302
  {
875
1303
  "name": "x",
@@ -889,9 +1317,7 @@
889
1317
  "kind": "boolean"
890
1318
  }
891
1319
  }
892
- ],
893
- "kind": "struct",
894
- "path": "std::embedded_curve_ops::EmbeddedCurvePoint"
1320
+ ]
895
1321
  }
896
1322
  },
897
1323
  {
@@ -900,9 +1326,7 @@
900
1326
  "kind": "field"
901
1327
  }
902
1328
  }
903
- ],
904
- "kind": "struct",
905
- "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request::KeyValidationRequest"
1329
+ ]
906
1330
  }
907
1331
  },
908
1332
  {
@@ -911,9 +1335,7 @@
911
1335
  "kind": "field"
912
1336
  }
913
1337
  }
914
- ],
915
- "kind": "struct",
916
- "path": "authwit::aztec::protocol_types::abis::validation_requests::key_validation_request_and_generator::KeyValidationRequestAndGenerator"
1338
+ ]
917
1339
  }
918
1340
  }
919
1341
  },
@@ -923,6 +1345,8 @@
923
1345
  "kind": "array",
924
1346
  "length": 16,
925
1347
  "type": {
1348
+ "kind": "struct",
1349
+ "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash",
926
1350
  "fields": [
927
1351
  {
928
1352
  "name": "value",
@@ -938,9 +1362,7 @@
938
1362
  "width": 32
939
1363
  }
940
1364
  }
941
- ],
942
- "kind": "struct",
943
- "path": "authwit::aztec::protocol_types::abis::note_hash::NoteHash"
1365
+ ]
944
1366
  }
945
1367
  }
946
1368
  },
@@ -950,6 +1372,8 @@
950
1372
  "kind": "array",
951
1373
  "length": 16,
952
1374
  "type": {
1375
+ "kind": "struct",
1376
+ "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier",
953
1377
  "fields": [
954
1378
  {
955
1379
  "name": "value",
@@ -971,9 +1395,7 @@
971
1395
  "kind": "field"
972
1396
  }
973
1397
  }
974
- ],
975
- "kind": "struct",
976
- "path": "authwit::aztec::protocol_types::abis::nullifier::Nullifier"
1398
+ ]
977
1399
  }
978
1400
  }
979
1401
  },
@@ -983,14 +1405,20 @@
983
1405
  "kind": "array",
984
1406
  "length": 5,
985
1407
  "type": {
1408
+ "kind": "struct",
1409
+ "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest",
986
1410
  "fields": [
987
1411
  {
988
1412
  "name": "call_context",
989
1413
  "type": {
1414
+ "kind": "struct",
1415
+ "path": "authwit::aztec::protocol_types::abis::call_context::CallContext",
990
1416
  "fields": [
991
1417
  {
992
1418
  "name": "msg_sender",
993
1419
  "type": {
1420
+ "kind": "struct",
1421
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
994
1422
  "fields": [
995
1423
  {
996
1424
  "name": "inner",
@@ -998,14 +1426,14 @@
998
1426
  "kind": "field"
999
1427
  }
1000
1428
  }
1001
- ],
1002
- "kind": "struct",
1003
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1429
+ ]
1004
1430
  }
1005
1431
  },
1006
1432
  {
1007
1433
  "name": "contract_address",
1008
1434
  "type": {
1435
+ "kind": "struct",
1436
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1009
1437
  "fields": [
1010
1438
  {
1011
1439
  "name": "inner",
@@ -1013,14 +1441,14 @@
1013
1441
  "kind": "field"
1014
1442
  }
1015
1443
  }
1016
- ],
1017
- "kind": "struct",
1018
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1444
+ ]
1019
1445
  }
1020
1446
  },
1021
1447
  {
1022
1448
  "name": "function_selector",
1023
1449
  "type": {
1450
+ "kind": "struct",
1451
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
1024
1452
  "fields": [
1025
1453
  {
1026
1454
  "name": "inner",
@@ -1030,9 +1458,7 @@
1030
1458
  "width": 32
1031
1459
  }
1032
1460
  }
1033
- ],
1034
- "kind": "struct",
1035
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
1461
+ ]
1036
1462
  }
1037
1463
  },
1038
1464
  {
@@ -1041,9 +1467,7 @@
1041
1467
  "kind": "boolean"
1042
1468
  }
1043
1469
  }
1044
- ],
1045
- "kind": "struct",
1046
- "path": "authwit::aztec::protocol_types::abis::call_context::CallContext"
1470
+ ]
1047
1471
  }
1048
1472
  },
1049
1473
  {
@@ -1074,9 +1498,7 @@
1074
1498
  "width": 32
1075
1499
  }
1076
1500
  }
1077
- ],
1078
- "kind": "struct",
1079
- "path": "authwit::aztec::protocol_types::abis::private_call_request::PrivateCallRequest"
1501
+ ]
1080
1502
  }
1081
1503
  }
1082
1504
  },
@@ -1086,14 +1508,20 @@
1086
1508
  "kind": "array",
1087
1509
  "length": 16,
1088
1510
  "type": {
1511
+ "kind": "struct",
1512
+ "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted",
1089
1513
  "fields": [
1090
1514
  {
1091
1515
  "name": "inner",
1092
1516
  "type": {
1517
+ "kind": "struct",
1518
+ "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest",
1093
1519
  "fields": [
1094
1520
  {
1095
1521
  "name": "msg_sender",
1096
1522
  "type": {
1523
+ "kind": "struct",
1524
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1097
1525
  "fields": [
1098
1526
  {
1099
1527
  "name": "inner",
@@ -1101,14 +1529,14 @@
1101
1529
  "kind": "field"
1102
1530
  }
1103
1531
  }
1104
- ],
1105
- "kind": "struct",
1106
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1532
+ ]
1107
1533
  }
1108
1534
  },
1109
1535
  {
1110
1536
  "name": "contract_address",
1111
1537
  "type": {
1538
+ "kind": "struct",
1539
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1112
1540
  "fields": [
1113
1541
  {
1114
1542
  "name": "inner",
@@ -1116,14 +1544,14 @@
1116
1544
  "kind": "field"
1117
1545
  }
1118
1546
  }
1119
- ],
1120
- "kind": "struct",
1121
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1547
+ ]
1122
1548
  }
1123
1549
  },
1124
1550
  {
1125
1551
  "name": "function_selector",
1126
1552
  "type": {
1553
+ "kind": "struct",
1554
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
1127
1555
  "fields": [
1128
1556
  {
1129
1557
  "name": "inner",
@@ -1133,9 +1561,7 @@
1133
1561
  "width": 32
1134
1562
  }
1135
1563
  }
1136
- ],
1137
- "kind": "struct",
1138
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
1564
+ ]
1139
1565
  }
1140
1566
  },
1141
1567
  {
@@ -1150,9 +1576,7 @@
1150
1576
  "kind": "field"
1151
1577
  }
1152
1578
  }
1153
- ],
1154
- "kind": "struct",
1155
- "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest"
1579
+ ]
1156
1580
  }
1157
1581
  },
1158
1582
  {
@@ -1163,19 +1587,21 @@
1163
1587
  "width": 32
1164
1588
  }
1165
1589
  }
1166
- ],
1167
- "kind": "struct",
1168
- "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
1590
+ ]
1169
1591
  }
1170
1592
  }
1171
1593
  },
1172
1594
  {
1173
1595
  "name": "public_teardown_call_request",
1174
1596
  "type": {
1597
+ "kind": "struct",
1598
+ "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest",
1175
1599
  "fields": [
1176
1600
  {
1177
1601
  "name": "msg_sender",
1178
1602
  "type": {
1603
+ "kind": "struct",
1604
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1179
1605
  "fields": [
1180
1606
  {
1181
1607
  "name": "inner",
@@ -1183,14 +1609,14 @@
1183
1609
  "kind": "field"
1184
1610
  }
1185
1611
  }
1186
- ],
1187
- "kind": "struct",
1188
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1612
+ ]
1189
1613
  }
1190
1614
  },
1191
1615
  {
1192
1616
  "name": "contract_address",
1193
1617
  "type": {
1618
+ "kind": "struct",
1619
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1194
1620
  "fields": [
1195
1621
  {
1196
1622
  "name": "inner",
@@ -1198,14 +1624,14 @@
1198
1624
  "kind": "field"
1199
1625
  }
1200
1626
  }
1201
- ],
1202
- "kind": "struct",
1203
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1627
+ ]
1204
1628
  }
1205
1629
  },
1206
1630
  {
1207
1631
  "name": "function_selector",
1208
1632
  "type": {
1633
+ "kind": "struct",
1634
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
1209
1635
  "fields": [
1210
1636
  {
1211
1637
  "name": "inner",
@@ -1215,9 +1641,7 @@
1215
1641
  "width": 32
1216
1642
  }
1217
1643
  }
1218
- ],
1219
- "kind": "struct",
1220
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
1644
+ ]
1221
1645
  }
1222
1646
  },
1223
1647
  {
@@ -1232,9 +1656,7 @@
1232
1656
  "kind": "field"
1233
1657
  }
1234
1658
  }
1235
- ],
1236
- "kind": "struct",
1237
- "path": "authwit::aztec::protocol_types::abis::public_call_request::PublicCallRequest"
1659
+ ]
1238
1660
  }
1239
1661
  },
1240
1662
  {
@@ -1243,10 +1665,14 @@
1243
1665
  "kind": "array",
1244
1666
  "length": 2,
1245
1667
  "type": {
1668
+ "kind": "struct",
1669
+ "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message",
1246
1670
  "fields": [
1247
1671
  {
1248
1672
  "name": "recipient",
1249
1673
  "type": {
1674
+ "kind": "struct",
1675
+ "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress",
1250
1676
  "fields": [
1251
1677
  {
1252
1678
  "name": "inner",
@@ -1254,9 +1680,7 @@
1254
1680
  "kind": "field"
1255
1681
  }
1256
1682
  }
1257
- ],
1258
- "kind": "struct",
1259
- "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
1683
+ ]
1260
1684
  }
1261
1685
  },
1262
1686
  {
@@ -1273,9 +1697,7 @@
1273
1697
  "width": 32
1274
1698
  }
1275
1699
  }
1276
- ],
1277
- "kind": "struct",
1278
- "path": "authwit::aztec::protocol_types::messaging::l2_to_l1_message::L2ToL1Message"
1700
+ ]
1279
1701
  }
1280
1702
  }
1281
1703
  },
@@ -1285,10 +1707,14 @@
1285
1707
  "kind": "array",
1286
1708
  "length": 16,
1287
1709
  "type": {
1710
+ "kind": "struct",
1711
+ "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData",
1288
1712
  "fields": [
1289
1713
  {
1290
1714
  "name": "log",
1291
1715
  "type": {
1716
+ "kind": "struct",
1717
+ "path": "authwit::aztec::protocol_types::abis::log::Log",
1292
1718
  "fields": [
1293
1719
  {
1294
1720
  "name": "fields",
@@ -1300,9 +1726,7 @@
1300
1726
  }
1301
1727
  }
1302
1728
  }
1303
- ],
1304
- "kind": "struct",
1305
- "path": "authwit::aztec::protocol_types::abis::log::Log"
1729
+ ]
1306
1730
  }
1307
1731
  },
1308
1732
  {
@@ -1321,9 +1745,7 @@
1321
1745
  "width": 32
1322
1746
  }
1323
1747
  }
1324
- ],
1325
- "kind": "struct",
1326
- "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
1748
+ ]
1327
1749
  }
1328
1750
  }
1329
1751
  },
@@ -1333,6 +1755,8 @@
1333
1755
  "kind": "array",
1334
1756
  "length": 1,
1335
1757
  "type": {
1758
+ "kind": "struct",
1759
+ "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash",
1336
1760
  "fields": [
1337
1761
  {
1338
1762
  "name": "value",
@@ -1356,9 +1780,7 @@
1356
1780
  "width": 32
1357
1781
  }
1358
1782
  }
1359
- ],
1360
- "kind": "struct",
1361
- "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
1783
+ ]
1362
1784
  }
1363
1785
  }
1364
1786
  },
@@ -1381,10 +1803,14 @@
1381
1803
  {
1382
1804
  "name": "historical_header",
1383
1805
  "type": {
1806
+ "kind": "struct",
1807
+ "path": "authwit::aztec::protocol_types::block_header::BlockHeader",
1384
1808
  "fields": [
1385
1809
  {
1386
1810
  "name": "last_archive",
1387
1811
  "type": {
1812
+ "kind": "struct",
1813
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
1388
1814
  "fields": [
1389
1815
  {
1390
1816
  "name": "root",
@@ -1400,14 +1826,14 @@
1400
1826
  "width": 32
1401
1827
  }
1402
1828
  }
1403
- ],
1404
- "kind": "struct",
1405
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
1829
+ ]
1406
1830
  }
1407
1831
  },
1408
1832
  {
1409
1833
  "name": "content_commitment",
1410
1834
  "type": {
1835
+ "kind": "struct",
1836
+ "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment",
1411
1837
  "fields": [
1412
1838
  {
1413
1839
  "name": "num_txs",
@@ -1433,18 +1859,20 @@
1433
1859
  "kind": "field"
1434
1860
  }
1435
1861
  }
1436
- ],
1437
- "kind": "struct",
1438
- "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment"
1862
+ ]
1439
1863
  }
1440
1864
  },
1441
1865
  {
1442
1866
  "name": "state",
1443
1867
  "type": {
1868
+ "kind": "struct",
1869
+ "path": "authwit::aztec::protocol_types::state_reference::StateReference",
1444
1870
  "fields": [
1445
1871
  {
1446
1872
  "name": "l1_to_l2_message_tree",
1447
1873
  "type": {
1874
+ "kind": "struct",
1875
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
1448
1876
  "fields": [
1449
1877
  {
1450
1878
  "name": "root",
@@ -1460,18 +1888,20 @@
1460
1888
  "width": 32
1461
1889
  }
1462
1890
  }
1463
- ],
1464
- "kind": "struct",
1465
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
1891
+ ]
1466
1892
  }
1467
1893
  },
1468
1894
  {
1469
1895
  "name": "partial",
1470
1896
  "type": {
1897
+ "kind": "struct",
1898
+ "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference",
1471
1899
  "fields": [
1472
1900
  {
1473
1901
  "name": "note_hash_tree",
1474
1902
  "type": {
1903
+ "kind": "struct",
1904
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
1475
1905
  "fields": [
1476
1906
  {
1477
1907
  "name": "root",
@@ -1487,14 +1917,14 @@
1487
1917
  "width": 32
1488
1918
  }
1489
1919
  }
1490
- ],
1491
- "kind": "struct",
1492
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
1920
+ ]
1493
1921
  }
1494
1922
  },
1495
1923
  {
1496
1924
  "name": "nullifier_tree",
1497
1925
  "type": {
1926
+ "kind": "struct",
1927
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
1498
1928
  "fields": [
1499
1929
  {
1500
1930
  "name": "root",
@@ -1510,14 +1940,14 @@
1510
1940
  "width": 32
1511
1941
  }
1512
1942
  }
1513
- ],
1514
- "kind": "struct",
1515
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
1943
+ ]
1516
1944
  }
1517
1945
  },
1518
1946
  {
1519
1947
  "name": "public_data_tree",
1520
1948
  "type": {
1949
+ "kind": "struct",
1950
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
1521
1951
  "fields": [
1522
1952
  {
1523
1953
  "name": "root",
@@ -1533,24 +1963,20 @@
1533
1963
  "width": 32
1534
1964
  }
1535
1965
  }
1536
- ],
1537
- "kind": "struct",
1538
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot"
1966
+ ]
1539
1967
  }
1540
1968
  }
1541
- ],
1542
- "kind": "struct",
1543
- "path": "authwit::aztec::protocol_types::partial_state_reference::PartialStateReference"
1969
+ ]
1544
1970
  }
1545
1971
  }
1546
- ],
1547
- "kind": "struct",
1548
- "path": "authwit::aztec::protocol_types::state_reference::StateReference"
1972
+ ]
1549
1973
  }
1550
1974
  },
1551
1975
  {
1552
1976
  "name": "global_variables",
1553
1977
  "type": {
1978
+ "kind": "struct",
1979
+ "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables",
1554
1980
  "fields": [
1555
1981
  {
1556
1982
  "name": "chain_id",
@@ -1587,6 +2013,8 @@
1587
2013
  {
1588
2014
  "name": "coinbase",
1589
2015
  "type": {
2016
+ "kind": "struct",
2017
+ "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress",
1590
2018
  "fields": [
1591
2019
  {
1592
2020
  "name": "inner",
@@ -1594,14 +2022,14 @@
1594
2022
  "kind": "field"
1595
2023
  }
1596
2024
  }
1597
- ],
1598
- "kind": "struct",
1599
- "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
2025
+ ]
1600
2026
  }
1601
2027
  },
1602
2028
  {
1603
2029
  "name": "fee_recipient",
1604
2030
  "type": {
2031
+ "kind": "struct",
2032
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1605
2033
  "fields": [
1606
2034
  {
1607
2035
  "name": "inner",
@@ -1609,14 +2037,14 @@
1609
2037
  "kind": "field"
1610
2038
  }
1611
2039
  }
1612
- ],
1613
- "kind": "struct",
1614
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2040
+ ]
1615
2041
  }
1616
2042
  },
1617
2043
  {
1618
2044
  "name": "gas_fees",
1619
2045
  "type": {
2046
+ "kind": "struct",
2047
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
1620
2048
  "fields": [
1621
2049
  {
1622
2050
  "name": "fee_per_da_gas",
@@ -1630,14 +2058,10 @@
1630
2058
  "kind": "field"
1631
2059
  }
1632
2060
  }
1633
- ],
1634
- "kind": "struct",
1635
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
2061
+ ]
1636
2062
  }
1637
2063
  }
1638
- ],
1639
- "kind": "struct",
1640
- "path": "authwit::aztec::protocol_types::abis::global_variables::GlobalVariables"
2064
+ ]
1641
2065
  }
1642
2066
  },
1643
2067
  {
@@ -1652,14 +2076,14 @@
1652
2076
  "kind": "field"
1653
2077
  }
1654
2078
  }
1655
- ],
1656
- "kind": "struct",
1657
- "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
2079
+ ]
1658
2080
  }
1659
2081
  },
1660
2082
  {
1661
2083
  "name": "tx_context",
1662
2084
  "type": {
2085
+ "kind": "struct",
2086
+ "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext",
1663
2087
  "fields": [
1664
2088
  {
1665
2089
  "name": "chain_id",
@@ -1676,10 +2100,14 @@
1676
2100
  {
1677
2101
  "name": "gas_settings",
1678
2102
  "type": {
2103
+ "kind": "struct",
2104
+ "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings",
1679
2105
  "fields": [
1680
2106
  {
1681
2107
  "name": "gas_limits",
1682
2108
  "type": {
2109
+ "kind": "struct",
2110
+ "path": "authwit::aztec::protocol_types::abis::gas::Gas",
1683
2111
  "fields": [
1684
2112
  {
1685
2113
  "name": "da_gas",
@@ -1697,14 +2125,14 @@
1697
2125
  "width": 32
1698
2126
  }
1699
2127
  }
1700
- ],
1701
- "kind": "struct",
1702
- "path": "authwit::aztec::protocol_types::abis::gas::Gas"
2128
+ ]
1703
2129
  }
1704
2130
  },
1705
2131
  {
1706
2132
  "name": "teardown_gas_limits",
1707
2133
  "type": {
2134
+ "kind": "struct",
2135
+ "path": "authwit::aztec::protocol_types::abis::gas::Gas",
1708
2136
  "fields": [
1709
2137
  {
1710
2138
  "name": "da_gas",
@@ -1722,14 +2150,14 @@
1722
2150
  "width": 32
1723
2151
  }
1724
2152
  }
1725
- ],
1726
- "kind": "struct",
1727
- "path": "authwit::aztec::protocol_types::abis::gas::Gas"
2153
+ ]
1728
2154
  }
1729
2155
  },
1730
2156
  {
1731
2157
  "name": "max_fees_per_gas",
1732
2158
  "type": {
2159
+ "kind": "struct",
2160
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
1733
2161
  "fields": [
1734
2162
  {
1735
2163
  "name": "fee_per_da_gas",
@@ -1743,14 +2171,14 @@
1743
2171
  "kind": "field"
1744
2172
  }
1745
2173
  }
1746
- ],
1747
- "kind": "struct",
1748
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
2174
+ ]
1749
2175
  }
1750
2176
  },
1751
2177
  {
1752
2178
  "name": "max_priority_fees_per_gas",
1753
2179
  "type": {
2180
+ "kind": "struct",
2181
+ "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees",
1754
2182
  "fields": [
1755
2183
  {
1756
2184
  "name": "fee_per_da_gas",
@@ -1764,250 +2192,64 @@
1764
2192
  "kind": "field"
1765
2193
  }
1766
2194
  }
1767
- ],
1768
- "kind": "struct",
1769
- "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
2195
+ ]
1770
2196
  }
1771
- }
1772
- ],
1773
- "kind": "struct",
1774
- "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
1775
- }
1776
- }
1777
- ],
1778
- "kind": "struct",
1779
- "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
1780
- }
1781
- }
1782
- ],
1783
- "kind": "struct",
1784
- "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs"
1785
- },
1786
- "visibility": "databus"
1787
- }
1788
- },
1789
- "bytecode": "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",
1790
- "debug_symbols": "7Vvdbts8DH2XXPtC/BOlvsqHD0PaZkOAIC3SdsBQ7N0nB5Pkpoo9ok2XNb4pIvscmeSh/mj3eXG7un769mW9/Xr3sLj673mxubtZPq7vtqn1vADeX3u4X2775sPjcve4uEIOsVustrfppwj/7BZf15vV4goQf3av0eh8RiOGgo7cAoegGRy9GweDRMjo9JsqHDW28F5ChnvVio6+hSZPGc3gXqD/7xYgc2iOhcbPoTkWGj3z0AjX0PgwERoELJYAyxtDE+bQHAtNbIcGqYZGJkLDIPIbzRChoBX7J6A7+ROg9QQigN8cokFQpakBBS4aUAy+wptBjR6yQel3wHF4wIIOKDihr0bOaI2RJtAkORkYB+o2sxIj5piTk3EwEGAJCMEE2EEeSuCGCcx7fXDW56z1oVmfP9JHSxRRiSZCrpo7Bo3yJn141ues9ZF30CeWsQ/sJEzow8EVgzgMNi9H4BrqJiA4Hi6gzThCiaNObHUuXXs/a3+x2uus/cVqH85e+wBc4Yzj2pOvB6wKTQm0dzaev7NSew+DBGs6m+ouEgeFFzk4UJK7MH/hk/mbphuuA10PCwaEF+Yv/VV/xQ3Op024lglfQ+1Z9zMt8Zkbn1bCvBCyHxo/r7BvWWFJzl13cG3de+M//lggjn01XmkI7y36+M2qUIRiEfNEEQEdYCmaO5yaIi99dIRZzs8kZ5zl/ERy8scfIJKEocqpbhzuqymehqtXc3sZXakiRKlRhGRU7yycu7PM2X7Pg7ex7SIIOS57NHLqDvbSjBfl7ZGTg2aDKO2TJrxNM00ZVyA+FrgXayGC+T3M0TJywSOOm5PefsSa/Apvjaf86w74j3YAHRGXlSetWi8sSo3r3XqzWX/78uLzMtf/aaeLlKEq4l5lmNgp3k5ROyUYKakFPbL9dtdTliAM3jQD0/EXjuMUsVO8naJ2SrBTmpuxgIXC4ZDSrhiOU8BOQTuF7BS2U8RO8XaK2inBTmmrH/IcFGJ8QRlbwkjrPplkZGv4ft3DabvH03ZPp+2eT9u9nLZ7f9ru9R27D/Sq+3Da7uNJu5fmqI3lQ8xIejiPCNgpaKeQncJ2itgp3k5RM8UHOyWaKXrkE9acMOj1MGEU7BS0U8hOYTtF7BRvp7S/X9f6IfWrUanBTolmSnB2CtgpaKeQkZJauD8SNM3zZQh4z4fHj/Y3vOMUslPYThE7xRspqUU98sj/LMXyAhCjPyiPpRbPR9E0t+/zrplEUophKsNFWhIxNb8vd+vl9WbVH+v7u0/bm3zKT83HH/f5Tq4D3O/ubla3T7tVXxGoxYA+Gwk6huQB9ENaXCdSjsn7Sx467/v7/QAJsYtQxkxPT8cGipnOrmOpqdFfAt8hFMmPP1AKA6Ujl9xMrv4C",
1791
- "brillig_names": [
1792
- "store_in_execution_cache_oracle_wrapper",
1793
- "call_private_function_internal",
1794
- "load",
1795
- "notify_created_nullifier_oracle_wrapper",
1796
- "store_in_execution_cache_oracle_wrapper",
1797
- "enqueue_public_function_call_internal"
1798
- ],
1799
- "verification_key": "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"
1800
- },
1801
- {
1802
- "name": "process_log",
1803
- "is_unconstrained": true,
1804
- "custom_attributes": [],
1805
- "abi": {
1806
- "error_types": {
1807
- "16775516380094354375": {
1808
- "error_kind": "fmtstring",
1809
- "item_types": [],
1810
- "length": 40
1811
- },
1812
- "17843811134343075018": {
1813
- "error_kind": "string",
1814
- "string": "Stack too deep"
1815
- }
1816
- },
1817
- "parameters": [
1818
- {
1819
- "name": "_log_ciphertext",
1820
- "type": {
1821
- "fields": [
1822
- {
1823
- "name": "storage",
1824
- "type": {
1825
- "kind": "array",
1826
- "length": 18,
1827
- "type": {
1828
- "kind": "field"
1829
- }
1830
- }
1831
- },
1832
- {
1833
- "name": "len",
1834
- "type": {
1835
- "kind": "integer",
1836
- "sign": "unsigned",
1837
- "width": 32
1838
- }
1839
- }
1840
- ],
1841
- "kind": "struct",
1842
- "path": "std::collections::bounded_vec::BoundedVec"
1843
- },
1844
- "visibility": "private"
1845
- },
1846
- {
1847
- "name": "_tx_hash",
1848
- "type": {
1849
- "kind": "field"
1850
- },
1851
- "visibility": "private"
1852
- },
1853
- {
1854
- "name": "_unique_note_hashes_in_tx",
1855
- "type": {
1856
- "fields": [
1857
- {
1858
- "name": "storage",
1859
- "type": {
1860
- "kind": "array",
1861
- "length": 64,
1862
- "type": {
1863
- "kind": "field"
1864
- }
1865
- }
1866
- },
1867
- {
1868
- "name": "len",
1869
- "type": {
1870
- "kind": "integer",
1871
- "sign": "unsigned",
1872
- "width": 32
1873
- }
2197
+ }
2198
+ ]
2199
+ }
2200
+ }
2201
+ ]
1874
2202
  }
1875
- ],
1876
- "kind": "struct",
1877
- "path": "std::collections::bounded_vec::BoundedVec"
1878
- },
1879
- "visibility": "private"
1880
- },
1881
- {
1882
- "name": "_first_nullifier_in_tx",
1883
- "type": {
1884
- "kind": "field"
1885
- },
1886
- "visibility": "private"
2203
+ }
2204
+ ]
1887
2205
  },
1888
- {
1889
- "name": "_recipient",
1890
- "type": {
1891
- "fields": [
1892
- {
1893
- "name": "inner",
1894
- "type": {
1895
- "kind": "field"
1896
- }
1897
- }
1898
- ],
1899
- "kind": "struct",
1900
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1901
- },
1902
- "visibility": "private"
1903
- }
1904
- ],
1905
- "return_type": null
1906
- },
1907
- "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
1908
- "debug_symbols": "tZbRCoMgGIXfxWsv0sq/9ipjDCsbglhYDUb07tOILbbrcxMd+fXzwg/OyjrTLI+79f0wsct1ZW5o9WwHH9O6cdYE65x93M/LLEsfUap9wzRqn/I06zCzi8iFrDkzvtv/qY6H9NaZmGS+8b95kscw0WeyoO3GI4DQgAoNqMEAlaEBAg2QaECOBhRoQIkGoE1WaJMV2mSFNpnQJhPaZEKbTGiTCW0yoU0mtMmENpmgJm8xPXWwunHmaDj94ttT4Zlfo/npPmMYWtMtwaQW9C1A6TUWkpcyXTvZK6qMi6qMkAh6Aw==",
1909
- "brillig_names": [
1910
- "process_log"
1911
- ]
1912
- },
1913
- {
1914
- "name": "unconstrained_is_consumable",
1915
- "is_unconstrained": true,
1916
- "custom_attributes": [],
1917
- "abi": {
2206
+ "visibility": "databus"
2207
+ },
1918
2208
  "error_types": {
1919
- "16761564377371454734": {
2209
+ "4939791462094160055": {
1920
2210
  "error_kind": "string",
1921
- "string": "Array index out of bounds"
2211
+ "string": "Message not authorized by account"
1922
2212
  },
1923
- "17843811134343075018": {
2213
+ "5019202896831570965": {
1924
2214
  "error_kind": "string",
1925
- "string": "Stack too deep"
2215
+ "string": "attempt to add with overflow"
1926
2216
  },
1927
- "206160798890201757": {
2217
+ "16761564377371454734": {
1928
2218
  "error_kind": "string",
1929
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2219
+ "string": "Array index out of bounds"
1930
2220
  },
1931
- "5019202896831570965": {
2221
+ "17843811134343075018": {
1932
2222
  "error_kind": "string",
1933
- "string": "attempt to add with overflow"
1934
- }
1935
- },
1936
- "parameters": [
1937
- {
1938
- "name": "on_behalf_of",
1939
- "type": {
1940
- "fields": [
1941
- {
1942
- "name": "inner",
1943
- "type": {
1944
- "kind": "field"
1945
- }
1946
- }
1947
- ],
1948
- "kind": "struct",
1949
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
1950
- },
1951
- "visibility": "private"
1952
- },
1953
- {
1954
- "name": "message_hash",
1955
- "type": {
1956
- "kind": "field"
1957
- },
1958
- "visibility": "private"
2223
+ "string": "Stack too deep"
1959
2224
  }
1960
- ],
1961
- "return_type": {
1962
- "abi_type": {
1963
- "kind": "boolean"
1964
- },
1965
- "visibility": "public"
1966
2225
  }
1967
2226
  },
1968
- "bytecode": "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",
1969
- "debug_symbols": "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",
2227
+ "bytecode": "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",
2228
+ "debug_symbols": "7Vvdbts6DH6XXPtCFEmR6qscDEPaZkOAIC3S9gAHxXn3ydkkualij2jTZY1vCiv+Ppnkpz/S7vPidnX99P3revvt7mFx9c/zYnN3s3xc321T63kBtP/t4X657ZsPj8vd4+LKk8Zusdrepktm+r9bfFtvVosr8On6Ndq7kNHea0FHboFVJYNjcONg4AgZna6xwr1CCx9YMzyIVHTUFhoDZjSBe4H+0i2A59AcC02YQ3MsNHLmoWGqoQk6ERoPvlgCxG8Mjc6hORaa2A6NxxoanggNAfMvNEGEghbfP8G7kz8BWk9ABPjFQRwElakZJaWiAUYNFR5a8BggG5Su1Y/D1Re0evYT+kqkjJYYcQKNnAcD+YG67SEcfY45Oh4HA4IvAUGYADvIUwnccADTXh8/63PW+uCsz2/pIyWKXhAnQi6SOwaJ/CZ9aNbnrPXhd9AnlrkP5Fgn9CF1xSDSweHlCFy0HgLU0XADbcYRShxl4qhz6dqHWfuL1V5m7S9Wez177RWowsmPa4+hJlgVChT3zsbzd5Zr7zoYYE1nU92F46DwwgcJJboL8xc+mb9puaE60eWwYID+wvzFP+ovu0F+2oRLWfBFa8+yX2mRztz4tBPmjZDC0Ph5h33LDot87rqDa+veG//xaQE7CtV4wSG8t+jjD6uMEYpFRBNFBO/Al6K581NL5KXPDp3l/ExyxlnOTyQnfXwCkSTUKqe4cXiopgQc7l7N42V0pYoQuUYR0pvN3lk4d2eJsv2BBm9j20UQdFTOaOjEHZylyV+Ut0cyB8kGYTonTXibVpoyr4BDLPDA1kIE0XuYI2XmQvB+3Jz09iPWwS/w1njy3+5A+GgHvEOksvOkXeuFRalxvVtvNuvvX198Xub6P+3hwmWqMrtXI4ztlGCniJ2iRkpqQY9sv90NmCXQwZvm/nOSL8deOI5T2E4JdorYKWqnNA9j6guF9JDSrhiOU8BO8XYK2ilkp7CdEuwUsVPUTmmrr3kN0hhfUMa2MJR6TsafeXj7aPh+3cNpu/en7R5P2z2dtns+bffhtN3LO3av+Kp7PW338aTdc3PWxvIhZkQ5XEcY7BRvp6CdQnYK2ynBThEzJaidEs0UOfIJax4wPsjhgBGwU7ydgnYK2SlspwQ7pf39utQPqV/NSlE7JZop6uwUsFO8nYJGSmr5fUrQNC+UKRACHaYf7W94xylop5CdwnZKMFJSC3vkkf9Z0lDy0+hqLW1fHkstmlPRtLbvx11zEHEphgkPN2lJxNT8d7lbL683qz6t7+8+bW9ylp+aj//d5zu5DnC/u7tZ3T7tVn1FoBYD+tGI0BEkD6Cf0uw65pIm738K0IXQ3+8niMYuQpkzPT2lDRgznVxHXIdG/xOEzkOR/PgDuTA8d+iSm8nVHw==",
1970
2229
  "brillig_names": [
1971
- "unconstrained_is_consumable"
1972
- ]
2230
+ "store_in_execution_cache_oracle_wrapper",
2231
+ "call_private_function_internal",
2232
+ "load",
2233
+ "notify_created_nullifier_oracle_wrapper",
2234
+ "store_in_execution_cache_oracle_wrapper",
2235
+ "enqueue_public_function_call_internal"
2236
+ ],
2237
+ "verification_key": "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"
1973
2238
  },
1974
2239
  {
1975
- "name": "consume",
2240
+ "name": "is_reject_all",
1976
2241
  "is_unconstrained": true,
1977
2242
  "custom_attributes": [
1978
- "public"
2243
+ "public",
2244
+ "view"
1979
2245
  ],
1980
2246
  "abi": {
1981
- "error_types": {
1982
- "12737498021964987455": {
1983
- "error_kind": "string",
1984
- "string": "unauthorized"
1985
- },
1986
- "16761564377371454734": {
1987
- "error_kind": "string",
1988
- "string": "Array index out of bounds"
1989
- },
1990
- "17843811134343075018": {
1991
- "error_kind": "string",
1992
- "string": "Stack too deep"
1993
- },
1994
- "206160798890201757": {
1995
- "error_kind": "string",
1996
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1997
- },
1998
- "5019202896831570965": {
1999
- "error_kind": "string",
2000
- "string": "attempt to add with overflow"
2001
- },
2002
- "715723737710351018": {
2003
- "error_kind": "string",
2004
- "string": "rejecting all"
2005
- }
2006
- },
2007
2247
  "parameters": [
2008
2248
  {
2009
2249
  "name": "on_behalf_of",
2010
2250
  "type": {
2251
+ "kind": "struct",
2252
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
2011
2253
  "fields": [
2012
2254
  {
2013
2255
  "name": "inner",
@@ -2015,225 +2257,44 @@
2015
2257
  "kind": "field"
2016
2258
  }
2017
2259
  }
2018
- ],
2019
- "kind": "struct",
2020
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2021
- },
2022
- "visibility": "private"
2023
- },
2024
- {
2025
- "name": "inner_hash",
2026
- "type": {
2027
- "kind": "field"
2028
- },
2029
- "visibility": "private"
2030
- }
2031
- ],
2032
- "return_type": {
2033
- "abi_type": {
2034
- "kind": "field"
2035
- },
2036
- "visibility": "public"
2037
- }
2038
- },
2039
- "bytecode": "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",
2040
- "debug_symbols": "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",
2041
- "brillig_names": [
2042
- "consume"
2043
- ]
2044
- },
2045
- {
2046
- "name": "set_authorized",
2047
- "is_unconstrained": true,
2048
- "custom_attributes": [
2049
- "public"
2050
- ],
2051
- "abi": {
2052
- "error_types": {
2053
- "16761564377371454734": {
2054
- "error_kind": "string",
2055
- "string": "Array index out of bounds"
2056
- },
2057
- "17843811134343075018": {
2058
- "error_kind": "string",
2059
- "string": "Stack too deep"
2060
- },
2061
- "206160798890201757": {
2062
- "error_kind": "string",
2063
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2064
- },
2065
- "5019202896831570965": {
2066
- "error_kind": "string",
2067
- "string": "attempt to add with overflow"
2068
- }
2069
- },
2070
- "parameters": [
2071
- {
2072
- "name": "message_hash",
2073
- "type": {
2074
- "kind": "field"
2075
- },
2076
- "visibility": "private"
2077
- },
2078
- {
2079
- "name": "authorize",
2080
- "type": {
2081
- "kind": "boolean"
2082
- },
2083
- "visibility": "private"
2084
- }
2085
- ],
2086
- "return_type": null
2087
- },
2088
- "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgMEAicCBAQAHxgABAADgEcdAIBIgEgBLgiARwABLgiASAACJQAAAFIlAAAAbygCAAEEgEknAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAABMQeAgAEAScCBQACLQgBBicCBwQDABABBwEnAwYEAQAoBgIHLQwHCC0OBQgAKAgCCC0OBAgnAgQAAC0IAQUnAgcEBAAQAQcBJwMFBAEAKAUCBy0MBwgtDgQIACgIAggtDgQIACgIAggtDgQILQ0FBwAoBwIHLQ4HBSsCAAcAAAAAAAAAAAIAAAAAAAAAAC0IAQgnAgkEBQAQAQkBJwMIBAEAKAgCCS0MCQotDgQKACgKAgotDgQKACgKAgotDgQKACgKAgotDgcKLQ0FCQAoCQIJLQ4JBS0IAQkAAAECAS0OBQktDQgFACgFAgUtDgUILQgBBQAAAQIBLQ4IBS0IAQgAAAECAS4KgEUACC0IAQoAAAECAS4KgEQACicCCwQCLgiARQADIwAAAZ0MOAMLDCQCAAwAAARRIwAAAa8tDQoGCygABoBEAAwkAgAMAAABzCcCDQQAPAkBDScCBgQMLQgADC0MCQ0tDAUOLQwIDy0MChAAEAAGACUAAATtLQQAAC0NCQYtDQUMLQ0IDS0OBgktDgwFLQ4NCCcCBQEBLQ4FCgEoAAyARgAILQ0IBgo4BgQICygACIBEAAkkAgAJAAACOiUAAAZFLQgBCCcCCQQDABABCQEnAwgEAQAoCAIJLQwJCi0OBgoAKAoCCi0OAQotCAEBJwIGBAQAEAEGAScDAQQBACgBAgYtDAYJLQ4ECQAoCQIJLQ4ECQAoCQIJLQ4ECS0NAQYAKAYCBi0OBgEtCAEGJwIJBAUAEAEJAScDBgQBACgGAgktDAkKLQ4ECgAoCgIKLQ4ECgAoCgIKLQ4ECgAoCgIKLQ4HCi0NAQcAKAcCBy0OBwEtCAEHAAABAgEtDgEHLQ0GAQAoAQIBLQ4BBi0IAQEAAAECAS0OBgEtCAEGAAABAgEuCoBFAAYtCAEJAAABAgEuCoBEAAkuCIBFAAMjAAADOgw4AwsKJAIACgAAA94jAAADTC0NCQMLKAADgEQACCQCAAgAAANpJwIKBAA8CQEKJwIDBAotCAAKLQwHCy0MAQwtDAYNLQwJDgAQAAMAJQAABO0tBAAALQ0HAy0NAQgtDQYKLQ4DBy0OCAEtDgoGLQ4FCQEoAAiARgADLQ0DAQo4AQQDCygAA4BEAAQkAgAEAAAD0iUAAAZFHAwCAwAwDAADAAEmJAIACgAAA+sjAAAEQCcCDAQCDDgDDA0kAgANAAAEAiUAAAZXACgIAgwAOAwDDS0NDQonAgwEDS0IAA0tDAcOLQwBDy0MBhAtDAkRLQwKEgAQAAwAJQAABmktBAAAIwAABEABKAADgEYACi0MCgMjAAADOiQCAAwAAAReIwAABLMnAg0EAgw4Aw0OJAIADgAABHUlAAAGVwAoBgINADgNAw4tDQ4MJwINBA4tCAAOLQwJDy0MBRAtDAgRLQwKEi0MDBMAEAANACUAAAZpLQQAACMAAASzASgAA4BGAAwtDAwDIwAAAZ0oAIAEBHgADQAAAIAEgAMkAIADAAAE7CoBAAEF96Hzr6Wt1Mo8AQECJiUAAATELgiARQAFIwAABP0NKAAFgEMABiQCAAYAAAVtIwAABRItDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAFiyMAAAY8LQ0BBy0NAggtDQMJLQ0ECicCDAQEDDgFDA0kAgANAAAFsiUAAAZXACgIAgwAOAwFDS0NDQsnAg0EAww4BQ0OJAIADgAABdclAAAGVwAoBwINADgNBQ4tDQ4MADgLDA0nAgwEBAw4BQwOJAIADgAABgElAAAGVy4EAAiAAygAgAQEAAUlAAAHlC4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAAY8LQwGBSMAAAT9KgEAAQUC3G4ngHYSnTwBAQImKgEAAQXonQn+oREtDjwBAQImJQAABMQtDQMGLQ0EBwsoAAeARAAIJAIACAAABo8nAgkEADwJAQkLKAAGgEMAByQCAAcAAAcgIwAABqQtDQEGLQ0CBy0NAwgtDQQJJwILBAMMOAgLDCQCAAwAAAbLJQAABlcuBAAGgAMoAIAEBAAEJQAAB5QuCIAFAAoAKAoCCwA4CwgMLQ4FDAEoAAiARgAFDjgIBQYkAgAGAAAHCyUAAAgiLQ4KAS0OBwItDgUDLQ4JBCMAAAeTJwIGBActCAAHLQwBCC0MAgktDAMKLQwECwAQAAYAJQAABO0tBAAALQ0BBi0NAgctDQQILgQABoADKACABAQABCUAAAeULgiABQAJACgJAgoBKAAKgEUACy0OBQstDgkBLQ4HAi4KgEYAAy0OCAQjAAAHkyYuAYADgAYLAIAGAAKAByQAgAcAAAevIwAAB7ouAIADgAUjAAAIIS4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAAgNLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAAfcKAGABQQAAQMAgAYAAoAGIwAACCEmKgEAAQVFp8pxGUHkFTwBAQImLgAYyhjK",
2089
- "debug_symbols": "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",
2090
- "brillig_names": [
2091
- "set_authorized"
2092
- ]
2093
- },
2094
- {
2095
- "name": "public_dispatch",
2096
- "is_unconstrained": true,
2097
- "custom_attributes": [
2098
- "public"
2099
- ],
2100
- "abi": {
2101
- "error_types": {
2102
- "12737498021964987455": {
2103
- "error_kind": "string",
2104
- "string": "unauthorized"
2105
- },
2106
- "16761564377371454734": {
2107
- "error_kind": "string",
2108
- "string": "Array index out of bounds"
2109
- },
2110
- "17843811134343075018": {
2111
- "error_kind": "string",
2112
- "string": "Stack too deep"
2113
- },
2114
- "206160798890201757": {
2115
- "error_kind": "string",
2116
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2117
- },
2118
- "2830029349304997821": {
2119
- "error_kind": "fmtstring",
2120
- "item_types": [
2121
- {
2122
- "kind": "field"
2123
- }
2124
- ],
2125
- "length": 27
2126
- },
2127
- "5019202896831570965": {
2128
- "error_kind": "string",
2129
- "string": "attempt to add with overflow"
2130
- },
2131
- "5444967152290923376": {
2132
- "error_kind": "string",
2133
- "string": "Function is_consumable can only be called statically"
2134
- },
2135
- "6304245522015439386": {
2136
- "error_kind": "string",
2137
- "string": "Function _set_authorized can only be called internally"
2138
- },
2139
- "715723737710351018": {
2140
- "error_kind": "string",
2141
- "string": "rejecting all"
2142
- },
2143
- "9474245853673257536": {
2144
- "error_kind": "string",
2145
- "string": "Function is_reject_all can only be called statically"
2146
- }
2147
- },
2148
- "parameters": [
2149
- {
2150
- "name": "selector",
2151
- "type": {
2152
- "kind": "field"
2260
+ ]
2153
2261
  },
2154
2262
  "visibility": "private"
2155
2263
  }
2156
2264
  ],
2157
- "return_type": null
2158
- },
2159
- "bytecode": "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",
2160
- "debug_symbols": "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",
2161
- "brillig_names": [
2162
- "public_dispatch"
2163
- ]
2164
- },
2165
- {
2166
- "name": "sync_notes",
2167
- "is_unconstrained": true,
2168
- "custom_attributes": [],
2169
- "abi": {
2170
- "error_types": {
2171
- "13649294680379557736": {
2172
- "error_kind": "string",
2173
- "string": "extend_from_bounded_vec out of bounds"
2174
- },
2175
- "14657895983200220173": {
2176
- "error_kind": "string",
2177
- "string": "Attempted to read past the length of a CapsuleArray"
2178
- },
2179
- "16761564377371454734": {
2180
- "error_kind": "string",
2181
- "string": "Array index out of bounds"
2182
- },
2183
- "16775516380094354375": {
2184
- "error_kind": "fmtstring",
2185
- "item_types": [],
2186
- "length": 40
2187
- },
2188
- "16954218183513903507": {
2189
- "error_kind": "string",
2190
- "string": "Attempted to read past end of BoundedVec"
2191
- },
2192
- "17843811134343075018": {
2193
- "error_kind": "string",
2194
- "string": "Stack too deep"
2195
- },
2196
- "2920182694213909827": {
2197
- "error_kind": "string",
2198
- "string": "attempt to subtract with overflow"
2265
+ "return_type": {
2266
+ "abi_type": {
2267
+ "kind": "boolean"
2199
2268
  },
2200
- "3305101268118424981": {
2269
+ "visibility": "public"
2270
+ },
2271
+ "error_types": {
2272
+ "206160798890201757": {
2201
2273
  "error_kind": "string",
2202
- "string": "Attempted to delete past the length of a CapsuleArray"
2203
- },
2204
- "3367683922240523006": {
2205
- "error_kind": "fmtstring",
2206
- "item_types": [
2207
- {
2208
- "kind": "field"
2209
- }
2210
- ],
2211
- "length": 58
2274
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2212
2275
  },
2213
2276
  "5019202896831570965": {
2214
2277
  "error_kind": "string",
2215
2278
  "string": "attempt to add with overflow"
2216
2279
  },
2217
- "5727012404371710682": {
2280
+ "9474245853673257536": {
2218
2281
  "error_kind": "string",
2219
- "string": "push out of bounds"
2282
+ "string": "Function is_reject_all can only be called statically"
2220
2283
  },
2221
- "6753155520859132764": {
2284
+ "16761564377371454734": {
2222
2285
  "error_kind": "string",
2223
- "string": "Failed to deliver note"
2286
+ "string": "Array index out of bounds"
2224
2287
  },
2225
- "8830323656616886390": {
2288
+ "17843811134343075018": {
2226
2289
  "error_kind": "string",
2227
- "string": "Got a public log emitted by a different contract"
2290
+ "string": "Stack too deep"
2228
2291
  }
2229
- },
2230
- "parameters": [],
2231
- "return_type": null
2292
+ }
2232
2293
  },
2233
- "bytecode": "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",
2234
- "debug_symbols": "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",
2294
+ "bytecode": "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",
2295
+ "debug_symbols": "7Z3dbts8DIbvJcc9EPWv3crwoehPVgQIkiJtP2Aoeu+z09pOIiGeRKFIpvdkmBsypJ7IJiVR8vvicXn/9nS72vzavix+/HxfrLcPd6+r7aa7ev+4WdzvVuv16un28M8L0f9DQu4VXp7vNv31y+vd7nXxgzQZcbNYbh73/3ey+5Jfq/Wyu5L64yaSdyKoL3FHIozSTiWEg9T2SzhIeyT8303nkfsbj/SRR70eyUK9QnvSlOkpkdLTWpovNa21HbVMCjcJO+AmIjWZsCYl7QfcFPwoq8h/uqMvy51wUe7oy6KjL4uOuSw6xl+UO1Zeljvuotxx9N3umMEdKeSRO4l4FvTghgth+mbpKSGtxm/WUkyyKZclBT14IUmeFzZy+F4j3aHonp8FPw4/L8CPxc+AH4dfQP/j8UP/4/CTAv2Px0+DH4ufBz8OP1Lgx+LnwI/DT0rwY/HD+G2Wnx1mUo2lU34K+QuPH/JnHr8AfnP8Rll7LNrzs7h/efw0+LH44f5l8XPofzx+6H8sfh79j8cP8y8sfgHjXx4/zL9w+CmB9XMeP8y/sPgRxm88fph/4fFD/hxDkVgUSkBBphtDUUhfE1CQE8RQNBLNBBRE7wQUhOQYyvfXyF8DFITkGIpFSE5AwTRRDAV7J1JQEJJjKNjlkIKCND+Ggv0IKSh4pkRQNHYOJKDINqFINUHR5hSKajPNdxQGL5xSxcI9Qd3mmCCHINmpfdZTRLDNAURFgqbNIFiRYKO1rjUJahCcI+jceN6CC1EsbrTetSJB1+biak2CiMVMgr7Nmb+aBJHNcAkikjAJBg2CTILogzyCRiCb4RJENsMkSMhmuASRzXAJIpIwCTZadFyTICIJk2Cj5cw1CbZZFJFFMJAc2hdkRPD7z4r+5whWWC8m7wcLhyvSaYLGuEG6W3SYGFJ/XlPM0LoBodeT7Oe59caoa3b+mslbe8XO/0UtpzVzzqswPjXssYmEO8YOzjvjZ97V4NTkvBb2vHDnx3hiUu+TOhTft9V9e1vN2FYr9Hn3jRueTYdYlLJ73728Yt+vl7ttdJ+2EqMXivRJoLSNTpzMQEFPiaFIDSgxlDbnfM5DUegpCSjoKTEU3eaEnwxyhCLMzEBXjKPirqk+ItjmhF9FgqbNDCiLIKmpfYYigm2mSxUJNlqUWpNgm+G1IsFGi1LzCFozts9HkaTRYqwsglpM7zQVUR8MbW7zqkfQiTaXL2sSRDbDJNjogY5ZBI0c22eMiAi2WYxVkWCru6grEkQsZhJUyKi5BDGqYxLUyGaYBDE/yCaIOWomwUYP9KtJEH2QSbDRowLzCI4FSGSCjAgim2ESbPRVTRUJNvqyoZoEEUl4BH2jLxyqSRDzg1yCiMVMgoT5wVmCatqkpNTpOolvdLtrTYKIxUyCCrGYSxCxmEsQsZhJEHXUbILIZpgEDfoglyCyGSZBi2yGSxDZDJcgspl5gtqNBO3pSpNv9P1LFQl6zPJzCSIWMwkG5INcghiT8AgG1PJzCaKWn7kbIpAGQSZBPAeZBBs9u6UiQdTynxDsoJCQyZGaGw/4clpFOumK9KAHQ8HEdowo0NEFOj5fJ12be/7Qie5PrkQrXYM5q2VLtHyRLV9kKxTZCiW2SFCRVsnvRVRki4rald7xNquli7R8iZaSRVou+xlDOsk9iOEVo0EmdPKfS5S+i8/bcQW+pWfEZnRCvo5X+Qx8/jOTQr4dmb5vZ3Tyf1NJBXaowE76fg1m6NfByVjH5OuoAjvp1+2e10mvQc/oFNgxBXbSK2sHv09CJx3Xz/+m1uXruAI7XhTomHydUHAvhPzngRKqQCfk65Au0CmwIwvaI/P7jlJUoJPZDz66q//vdqu7+/XypdPoP3zbPLyutpuvy9ffz8Mn97vVer16un3ebR+Wj2+75e16+9B/thBf//zsOvyNDGqfwXWX/XHZ9HnZN0YG3X1qO6ud5T8=",
2235
2296
  "brillig_names": [
2236
- "sync_notes"
2297
+ "is_reject_all"
2237
2298
  ]
2238
2299
  },
2239
2300
  {
@@ -2243,24 +2304,6 @@
2243
2304
  "public"
2244
2305
  ],
2245
2306
  "abi": {
2246
- "error_types": {
2247
- "16761564377371454734": {
2248
- "error_kind": "string",
2249
- "string": "Array index out of bounds"
2250
- },
2251
- "17843811134343075018": {
2252
- "error_kind": "string",
2253
- "string": "Stack too deep"
2254
- },
2255
- "206160798890201757": {
2256
- "error_kind": "string",
2257
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2258
- },
2259
- "5019202896831570965": {
2260
- "error_kind": "string",
2261
- "string": "attempt to add with overflow"
2262
- }
2263
- },
2264
2307
  "parameters": [
2265
2308
  {
2266
2309
  "name": "reject",
@@ -2270,31 +2313,8 @@
2270
2313
  "visibility": "private"
2271
2314
  }
2272
2315
  ],
2273
- "return_type": null
2274
- },
2275
- "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYdAIBGgEYBLgiARgABJQAAAEwlAAAAYigCAAEEgEcnAgIEADsNAAEAAigAgEMEAAMoAIBEBAAAKACARQQAASYlAAADmx4CAAMBJwIEAAEtCAEFJwIGBAMAEAEGAScDBQQBACgFAgYtDAYHLQ4EBwAoBwIHLQ4DBycCAwAALQgBBCcCBgQEABABBgEnAwQEAQAoBAIGLQwGBy0OAwcAKAcCBy0OAwcAKAcCBy0OAwctDQQGACgGAgYtDgYEKwIABgAAAAAAAAAAAgAAAAAAAAAALQgBBycCCAQFABABCAEnAwcEAQAoBwIILQwICS0OAwkAKAkCCS0OAwkAKAkCCS0OAwkAKAkCCS0OBgktDQQGACgGAgYtDgYELQgBBgAAAQIBLQ4EBi0NBwQAKAQCBC0OBActCAEEAAABAgEtDgcELQgBBwAAAQIBLgqARAAHLQgBCAAAAQIBJwIJAQAtDgkIJwIKBAIuCIBEAAIjAAABkww4AgoLJAIACwAAAjYjAAABpS0NCAIKOAIJBSQCAAUAAAG/JwIKBAA8CQEKJwICBAotCAAKLQwGCy0MBAwtDAcNLQwIDgAQAAIAJQAAA8QtBAAALQ0GAi0NBAUtDQcKLQ4CBi0OBQQtDgoHJwICAQEtDgIIASgABYBFAAQtDQQCCjgCAwQKOAQJAyQCAAMAAAIqJQAABRwcDAEDADAMAAMAAiYkAgALAAACQyMAAAOKJwIMBAIMOAIMDSQCAA0AAAJaJQAABS4AKAUCDAA4DAINLQ0NCy0NBwwtDQgNCjgNCQ4kAgAOAAAChicCDwQAPAkBDwsoAAyAQwANJAIADQAAAxcjAAACmy0NBgwtDQQNLQ0HDi0NCA8nAhEEAww4DhESJAIAEgAAAsIlAAAFLi4EAAyAAygAgAQEAAQlAAAFQC4IgAUAEAAoEAIRADgRDhItDgsSASgADoBFAAsOOA4LDCQCAAwAAAMCJQAABc4tDhAGLQ4NBC0OCwctDg8IIwAAA4onAgwEDS0IAA0tDAYOLQwEDy0MBxAtDAgRABAADAAlAAADxC0EAAAtDQYMLQ0EDS0NCA4uBAAMgAMoAIAEBAAEJQAABUAuCIAFAA8AKA8CEAEoABCARAARLQ4LES0ODwYtDg0ELgqARQAHLQ4OCCMAAAOKASgAAoBFAAstDAsCIwAAAZMoAIAEBHgADQAAAIAEgAMkAIADAAADwyoBAAEF96Hzr6Wt1Mo8AQECJiUAAAObLgiARAAFIwAAA9QNKAAFgEMABiQCAAYAAAREIwAAA+ktDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBFAAYkAgAHAAAEYiMAAAUTLQ0BBy0NAggtDQMJLQ0ECicCDAQEDDgFDA0kAgANAAAEiSUAAAUuACgIAgwAOAwFDS0NDQsnAg0EAww4BQ0OJAIADgAABK4lAAAFLgAoBwINADgNBQ4tDQ4MADgLDA0nAgwEBAw4BQwOJAIADgAABNglAAAFLi4EAAiAAygAgAQEAAUlAAAFQC4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAAUTLQwGBSMAAAPUKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXonQn+oREtDjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAFWyMAAAVmLgCAA4AFIwAABc0uAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFuS4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFiCgBgAUEAAEDAIAGAAKABiMAAAXNJioBAAEFRafKcRlB5BU8AQECJi4AGMoYyg==",
2276
- "debug_symbols": "7Z3bTus6EIbfpde98GF84lWWthCHLlSpalEpW9pCvPtOuohTatMQj7VU5P8GETITT77YnvH4wNvicXX/+nS73v7evSxufr0tNruHu8N6t+2u3t6Xi/v9erNZP92e/nkh+h9S6KPCy/Pdtr9+OdztD4sbSeSXi9X2sf/V2u4Rv9eb1eLG0PsyESYvB2HyahR2OiPsjbEfwt44eSr8z7Izx+fNUTaaQ+6yOVJYPQhLqaOwtDl7pI9PDj7KammP5kh9Xea4qzJHqesy57ro6Ouio6+LDsnrMsdclTlGXJc59LfNiU5CCfXJnFTWBTIfwi6E8cnKhYy0jk8mJUbZnMlKBhqsUFJdFjaRhVHuVPTIL4Afh5/V4Mfi58GPw8+h/vH4of6x+HnUPx4/B34cfkGCH4ufBT8GPyUE+LH4GfBj8cP4bZKfFQM/K8/5ScQvPH6In1n8/n6i+ufxi7L2s2jPj9B+efww/mDxM2i/PH6ofyx+FvWPxw/1j8XPIf/C44fxL4ufR/6Fx4/Aj8UP+RcWv4DxG48f8i8cflogfs5AwaRQCkUi0s1AQfiagYKYIIWiCFBSKPDeKRQNl5yBgjxVCoXgkjNQ4JJTKAZpogwUuOQMFLjkFAp2OeSgIMxPoWA/Qg4K+pQUCnYOpFBItAlF6REKmXMoqs0w38kwWOG0LhY+EmxzTDCHoLTj+1l/vk6TdJsDiJoE23SCFQk2uta1JsE2s2izCDoXYbiQ+OJG17vWJNjm5GpFgha+mEuQQJBJENEMk6CDJ+ESRDTDJOhRB7kEEc0wCQZEM1yCBIJMgohmeARNo+uIaxKEJ2ESlPAkXIKYJ+ESbHNRxCyCQarh/YJKCCqM6pgEdYX5YunjKfOnM9J5gsa4QbqbdBgZyt62lKF1A0JPo6yTf4y3P9h4+snkKfxg47+xltOZCeO1ir2GpvCpiFTaCzPY44UduWT/tQL5YX0HhVFU6z/t9RtnUNe2XYloO6nLtjsfH+28o8vCUpINsevtIrJT8f5dXZv+UYtohZZ03mE3ugl9AgpqSgoltBkcXYRiG809TEBBTUmhSNSUDJQ2E08qqAhFmIkBl4ijs+5V/TlB1WbiqSZBAsEpglLrk8g6IdhmuFSRYKNbjCsSpDbda02C8MXTBK2J7+cTT9LogZazCJIQEYZI6mCjR1rWJNjmNFpNgohmmAQb3V46i6AZk+bGiIRgm4uCKhJs9HDLegSdgC/mEkREzSTYaNK0JkFEM0yCyA9yCTa6gb8mQYzqmAQJdZBLEP3gNEEXF0eacH7CkGt0A39NgsiwMglaeBImQQdPwiUIT8IliPwgk2Cj288rEgzID04S1ONmGa1lQhD5QR5BL+CLuQThi7kE4YuZBJHlZxOEJ2ESbPSg45oEUQeZBDFPwiZIIMgkiGiGSRAr0b9BkFwkaEVCEHWQSdAgy88k2OhBxzUJIh5kEsRuCDZBrH5jEsRafuZuCO+xZoFJEDNNbIKogzyCAWv5zwj2UHw2SHZ6OG7BkT5TkSK/rSTQUE4wJtUxBTphvo7UBTr5pnXxzAkplCrSsiVaX5zJOKVVVBYVlUVFZZmiskxRWbboe9mislzRe32x8XdKK5RofREUTmkVtZSg5vcx+YUVQQwnIQaV6MiCfknmW/HlclSBbfmJgQkdKtDx8xmQLtApKCffbi/r2IJvagvKcQXl5NtrMEO9Dk4lOnl/O6FTUE5+8+yEjp+to4Qu0CkoJ7/A4OT75HTc7G+qlCrQKShHz4+HVH4DzITO/LagjC7Qmd8fqPz/UZvQmR8TKldQjit4H19Qd3zB9wkz68F7d/Xv3X59d79ZvXQa/c3X7cNhvdt+XB7+ex7u3O/Xm8366fZ5v3tYPb7uV7eb3UN/byE+fvzqPtxSeXP0092l9HopvT92If1db7u7viu1K/l/",
2277
- "brillig_names": [
2278
- "set_reject_all"
2279
- ]
2280
- },
2281
- {
2282
- "name": "is_reject_all",
2283
- "is_unconstrained": true,
2284
- "custom_attributes": [
2285
- "public",
2286
- "view"
2287
- ],
2288
- "abi": {
2316
+ "return_type": null,
2289
2317
  "error_types": {
2290
- "16761564377371454734": {
2291
- "error_kind": "string",
2292
- "string": "Array index out of bounds"
2293
- },
2294
- "17843811134343075018": {
2295
- "error_kind": "string",
2296
- "string": "Stack too deep"
2297
- },
2298
2318
  "206160798890201757": {
2299
2319
  "error_kind": "string",
2300
2320
  "string": "Storage slot 0 not allowed. Storage slots must start from 1."
@@ -2303,40 +2323,20 @@
2303
2323
  "error_kind": "string",
2304
2324
  "string": "attempt to add with overflow"
2305
2325
  },
2306
- "9474245853673257536": {
2326
+ "16761564377371454734": {
2307
2327
  "error_kind": "string",
2308
- "string": "Function is_reject_all can only be called statically"
2309
- }
2310
- },
2311
- "parameters": [
2312
- {
2313
- "name": "on_behalf_of",
2314
- "type": {
2315
- "fields": [
2316
- {
2317
- "name": "inner",
2318
- "type": {
2319
- "kind": "field"
2320
- }
2321
- }
2322
- ],
2323
- "kind": "struct",
2324
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2325
- },
2326
- "visibility": "private"
2327
- }
2328
- ],
2329
- "return_type": {
2330
- "abi_type": {
2331
- "kind": "boolean"
2328
+ "string": "Array index out of bounds"
2332
2329
  },
2333
- "visibility": "public"
2330
+ "17843811134343075018": {
2331
+ "error_kind": "string",
2332
+ "string": "Stack too deep"
2333
+ }
2334
2334
  }
2335
2335
  },
2336
- "bytecode": "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",
2337
- "debug_symbols": "7Z3bbuMsEMffJde9YDizr7L6VPWQrSJFSZWmn7Sq+u5rp7FzAMULg6pk+d9UdcJkhp8xM8CAP2bP88f3l/vF6tf6bfbj58dsuX562C7Wq+7q4/Nu9rhZLJeLl/vjj2ei/0NC7gTeXh9W/fXb9mGznf0gLRzdzear593/QXU/8muxnHdXUn7eReVdV2Rf3JEIY2mnEoWD1HZfOEh7Uvi/u84i9zcWmROLejmShXKF+qQpk1MiJae1NHsxrbUdpYxOECRhB9xEdHRzbIo3+QE3BT+WVWS/zNHXZU64KnP0ddHR10XHXBcd46/KHCuvyxx3VeY4+m5zzGCOFPLEnIQ/C3oww4Uj7yddSJRW4y9rKQ5lUyZLCnqwQpK8XNjI4XeNdMdFd/ws+HH4eQF+LH4G/Dj8Atofjx/aH4efFGh/PH4a/Fj8PPhx+JECPxY/B34cflKCH4sfxm+T/KwY+Fk656cQv/D4IX7m8QvgN8VvLGtPi/b8LJ5fHj8Nfix+eH5Z/BzaH48f2h+Ln0f74/HD/AuLX8D4l8cP8y8cfkpg/ZzHD/MvLH6E8RuPH+ZfePwQP8dQJBaFElAQ6cZQFMLXBBTEBDEUjUAzAQXeOwEFLjmG8v058rcABS45hmLhkhNQME0UQ8HeiRQUuOQYCnY5pKAgzI+hYD9CCgr6lAiKxs6BBBTZJhSpDlC0OYei2gzzHYXBCqdUceGeoG5zTJBDkOyhftZTRLDNAURFgqZNJ1iRYKO5rjUJahCcIujceN6CC5EvbjTftSJB1+biak2C8MVMgr7Nmb+aBBHNcAnCkzAJBg2CTIJogzyCRiCa4RJENMMkSIhmuAQRzXAJwpMwCTaadFyTIDwJk2Cj6cw1CbaZFJFFMJAc6hdkRPD7z4r+5whWWC8m7wcNxyvSaYLGuKF0t+hwYEi9bTFD6waEXh/KOtoZb9QtG3/L5K29YeP/IpfTminjVRh7DXuqImGOsYPxzviJdzU4dTBeC3u5cGfHeGJSb5M6Lr6rq/v2upqxrlboy+YbN/RNx1iU+uqbvLxh22+Xu210n7YSoxWK9JmjtI1OnExAQUuJoUgNKDGUNud8LkNRaCkJKGgpMRTd5oSfDHKEIszEQFeMo+Kuqj4i2OaEX0WCps0IKIsgqUP9DEUE2wyXKhJsNCm1JsE23WtFgo0mpeYRtGasn488SaPJWFkEtRjn9bSI2mBoc5tXPYJOtLl8WZMgohkmwUYPdMwiaORYP2NERLDNZKyKBFvdRV2RIHwxk6BCRM0liFEdk6BGNMMkiPlBNkHMUTMJNnqgX02CaINMgo0eFZhHcExAIhNkRBDRDJNgo69qqkiw0ZcN1SQIT8Ij6Bt94VBNgpgf5BKEL2YSJMwPThJUh01KSp2vk/hGt7vWJAhfzCSo4Iu5BOGLuQThi5kEkUfNJohohknQoA1yCSKaYRK0iGa4BBHNcAkimpkmqN1I0J6vNPlG379UkaDHLD+XIHwxk2BAPMgliDEJj2BALj+XIHL5mbshAmkQZBJEP8gk2OjZLRUJIpf/jGAHhYRMjtTceMCX0yqSSWekBz0oCibWY0SBjC6Q8fky6dzcy4dOdB+5Eql0DuaklC2R8kW6fJGuUKQrlOgiQUVSJfeLqEgXFdUrveNtUkoXSfkSKSWLpFx2H0M6yT2I4RWjQSZk8vslSj/Fl/W4AtvSM2ITMiFfxqt8Bj6/z6SQr0emn9sJmfx7KqlADxXoST+vwQztOjgZy5h8GVWgJ/263csy6TXoCZkCPaZAT3pl7ej+JGTSfv3yPbUuX8YV6PGiQMbky4SCZyHk9wdKqAKZkC9DukCmQI8sqI/MbztKUYFMZjv47K7+f9gsHh6X87dOov/yffW0XaxX+8vt79fhm8fNYrlcvNy/btZP8+f3zfx+uX7qv5uJ/Z+fXYO/k0HtIrjusj8um74u+8rIoLtvbae10/wH",
2336
+ "bytecode": "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",
2337
+ "debug_symbols": "7Z3bTus6EIbfpde98GF84lWWthCHLlSpalEpW9pCvPtOuohTatOseCxU5P8GETITT75MMuPxgbfF4+r+9el2vf29e1nc/HpbbHYPd4f1btsdvb0vF/f79Wazfro9/fNC9D+k0EeFl+e7bX/8crjbHxY3ksgvF6vtY/+rtd0lfq83q8WNofdlIkxeDsLk1SjsdEbYG2M/hL1x8lT4n2Vnjs+bo2w0h9xlc6SwehCWUkdhaU1O2scrBx9ltfRHc6S+LnPcVZmj1HWZc1109HXR0ddFh+R1mWOuyhwjrssc+m5zYpBQQn0yJ5V1gcyHsAthvLLyMiOt45VJiVE2Z7KSgQYrlFSXhU1kYZQ7FT3yC+DH4Wc1+LH4efDj8HPwPx4/+B+Ln4f/8fg58OPwCxL8WPws+DH4KSHAj8XPgB+LH/pvk/ysGPhZec5PIn/h8UP+zOL3/YXqn8cvytrPoj0/wvvL44f+B4ufwfvL4wf/Y/Gz8D8eP/gfi59D/YXHD/1fFj+P+guPH4Efix/qLyx+Af03Hj/UXzj8tED+nIGCQaEUikSmm4GC9DUDBTlBCkURoKRQEL1TKBohOQMFdaoUCiEkZ6AgJKdQDMpEGSgIyRkoCMkpFKxyyEFBmp9CwXqEHBR8U1IoWDmQQiHRJhSlRyhkzqGoNtN8J8NghdO6WPhIsM0+wRyC0o73Z/35PE3SbXYgahJsMwhWJNjoXNeaBNusos0i6FyE4UISixud71qTYJuDqxUJWsRiLkECQSZBZDNMgg6RhEsQ2QyToIcPcgkim2ESDMhmuAQJBJkEkc3wCJpG5xHXJIhIwiQoEUm4BDFOwiXY5qSIWQSDVMP9BZUQVOjVMQnqCuPF0sdd5k9HpPMEjXGDdDfoMDKU/X5NKUPrBoSeRtk/28wbbX+w8fSTyVP4wcb/xVxOZyaM1yp+NTSFT02k0l6YwR4v7MglK0x+mN9BYRTV2v6xPXy77UpE20ldtt35eGnnHV0WlpJsiJ/eLiM7Fe/v1bUZH7WIVmhJ5x/sRhehT0CBp6RQQpvJ0UUottHawwQUeEoKRcJTMlDaLDypoCIUYSY6XCL2zrpb9ecEVZuFp5oECQSnCEqtTzLrhGCb6VJFgo0uMa5IkNoMrzUJIhZPE7Qm3p9PIkmjG1rOIkhCRBgi8cFGt7SsSbDNYbSaBJHNMAk2urx0FkEzFs2NEQnBNicFVSTY6OaW9Qg6gVjMJYiMmkmw0aJpTYLIZpgEUR/kEmx0AX9NgujVMQkSfJBLEN/BaYIuTo404XyHIdfoAv6aBFFhZRK0iCRMgg6RhEsQkYRLEPVBJsFGl59XJBhQH5wkqMfFMlrLhCDqgzyCXiAWcwkiFnMJIhYzCaLKzyaISMIk2OhGxzUJwgeZBDFOwiZIIMgkiGyGSRAz0f+CILlI0IqEIHyQSdCgys8k2OhGxzUJIh9kEsRqCDZBzH5jEsRcfuZqCO8xZ4FJECNNbILwQR7BgLn8ZwR7KD6bJDs9bLfgSJ+pSJFfVhJoaCcYk+qYAp0wX0fqAp38q3VxzwkplCrSsiVaX+zJOKVV1BYVtUVFbZmitkxRW7boedmitlzRfX2x8HdKK5RofZEUTmkVvSlBzf/G5CdWBDHshBhUoiMLvksy/xZfbkcV2JYfGJjQoQIdP58B6QKdgnby7+1lHVvwTG1BO66gnfz7Gszg18GpRCcfbyd0CtrJL56d0PGzdZTQBToF7eQnGJw8n5yOm/1MlVIFOgXt6Pn5kMovgJnQmf8uKKMLdOZ/D1T+/6hN6MzPCZUraMcV3I8v8B1f8HzCTD94747+vduv7+43q5dOoz/5un04rHfbj8PDf8/Dmfv9erNZP90+73cPq8fX/ep2s3vozy3Ex49f3YNbKm+Ocbo7lF4vpffHT0h/1tvurO9a7Vr+Hw==",
2338
2338
  "brillig_names": [
2339
- "is_reject_all"
2339
+ "set_reject_all"
2340
2340
  ]
2341
2341
  }
2342
2342
  ],
@@ -2406,19 +2406,40 @@
2406
2406
  "type": {
2407
2407
  "fields": [
2408
2408
  {
2409
- "name": "reject",
2409
+ "name": "on_behalf_of",
2410
2410
  "type": {
2411
- "kind": "boolean"
2411
+ "fields": [
2412
+ {
2413
+ "name": "inner",
2414
+ "type": {
2415
+ "kind": "field"
2416
+ }
2417
+ }
2418
+ ],
2419
+ "kind": "struct",
2420
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2421
+ }
2422
+ },
2423
+ {
2424
+ "name": "inner_hash",
2425
+ "type": {
2426
+ "kind": "field"
2412
2427
  }
2413
2428
  }
2414
2429
  ],
2415
2430
  "kind": "struct",
2416
- "path": "AuthRegistry::set_reject_all_parameters"
2431
+ "path": "AuthRegistry::consume_parameters"
2432
+ }
2433
+ },
2434
+ {
2435
+ "name": "return_type",
2436
+ "type": {
2437
+ "kind": "field"
2417
2438
  }
2418
2439
  }
2419
2440
  ],
2420
2441
  "kind": "struct",
2421
- "path": "AuthRegistry::set_reject_all_abi"
2442
+ "path": "AuthRegistry::consume_abi"
2422
2443
  },
2423
2444
  {
2424
2445
  "fields": [
@@ -2454,7 +2475,7 @@
2454
2475
  "type": {
2455
2476
  "fields": [
2456
2477
  {
2457
- "name": "on_behalf_of",
2478
+ "name": "approver",
2458
2479
  "type": {
2459
2480
  "fields": [
2460
2481
  {
@@ -2467,21 +2488,27 @@
2467
2488
  "kind": "struct",
2468
2489
  "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2469
2490
  }
2491
+ },
2492
+ {
2493
+ "name": "message_hash",
2494
+ "type": {
2495
+ "kind": "field"
2496
+ }
2497
+ },
2498
+ {
2499
+ "name": "authorize",
2500
+ "type": {
2501
+ "kind": "boolean"
2502
+ }
2470
2503
  }
2471
2504
  ],
2472
2505
  "kind": "struct",
2473
- "path": "AuthRegistry::is_reject_all_parameters"
2474
- }
2475
- },
2476
- {
2477
- "name": "return_type",
2478
- "type": {
2479
- "kind": "boolean"
2506
+ "path": "AuthRegistry::set_authorized_private_parameters"
2480
2507
  }
2481
2508
  }
2482
2509
  ],
2483
2510
  "kind": "struct",
2484
- "path": "AuthRegistry::is_reject_all_abi"
2511
+ "path": "AuthRegistry::set_authorized_private_abi"
2485
2512
  },
2486
2513
  {
2487
2514
  "fields": [
@@ -2490,40 +2517,19 @@
2490
2517
  "type": {
2491
2518
  "fields": [
2492
2519
  {
2493
- "name": "approver",
2494
- "type": {
2495
- "fields": [
2496
- {
2497
- "name": "inner",
2498
- "type": {
2499
- "kind": "field"
2500
- }
2501
- }
2502
- ],
2503
- "kind": "struct",
2504
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2505
- }
2506
- },
2507
- {
2508
- "name": "message_hash",
2509
- "type": {
2510
- "kind": "field"
2511
- }
2512
- },
2513
- {
2514
- "name": "authorize",
2520
+ "name": "reject",
2515
2521
  "type": {
2516
2522
  "kind": "boolean"
2517
2523
  }
2518
2524
  }
2519
2525
  ],
2520
2526
  "kind": "struct",
2521
- "path": "AuthRegistry::set_authorized_private_parameters"
2527
+ "path": "AuthRegistry::set_reject_all_parameters"
2522
2528
  }
2523
2529
  }
2524
2530
  ],
2525
2531
  "kind": "struct",
2526
- "path": "AuthRegistry::set_authorized_private_abi"
2532
+ "path": "AuthRegistry::set_reject_all_abi"
2527
2533
  },
2528
2534
  {
2529
2535
  "fields": [
@@ -2545,16 +2551,10 @@
2545
2551
  "kind": "struct",
2546
2552
  "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2547
2553
  }
2548
- },
2549
- {
2550
- "name": "message_hash",
2551
- "type": {
2552
- "kind": "field"
2553
- }
2554
2554
  }
2555
2555
  ],
2556
2556
  "kind": "struct",
2557
- "path": "AuthRegistry::is_consumable_parameters"
2557
+ "path": "AuthRegistry::is_reject_all_parameters"
2558
2558
  }
2559
2559
  },
2560
2560
  {
@@ -2565,7 +2565,7 @@
2565
2565
  }
2566
2566
  ],
2567
2567
  "kind": "struct",
2568
- "path": "AuthRegistry::is_consumable_abi"
2568
+ "path": "AuthRegistry::is_reject_all_abi"
2569
2569
  },
2570
2570
  {
2571
2571
  "fields": [
@@ -2589,25 +2589,25 @@
2589
2589
  }
2590
2590
  },
2591
2591
  {
2592
- "name": "inner_hash",
2592
+ "name": "message_hash",
2593
2593
  "type": {
2594
2594
  "kind": "field"
2595
2595
  }
2596
2596
  }
2597
2597
  ],
2598
2598
  "kind": "struct",
2599
- "path": "AuthRegistry::consume_parameters"
2599
+ "path": "AuthRegistry::is_consumable_parameters"
2600
2600
  }
2601
2601
  },
2602
2602
  {
2603
2603
  "name": "return_type",
2604
2604
  "type": {
2605
- "kind": "field"
2605
+ "kind": "boolean"
2606
2606
  }
2607
2607
  }
2608
2608
  ],
2609
2609
  "kind": "struct",
2610
- "path": "AuthRegistry::consume_abi"
2610
+ "path": "AuthRegistry::is_consumable_abi"
2611
2611
  },
2612
2612
  {
2613
2613
  "fields": [
@@ -2655,75 +2655,75 @@
2655
2655
  }
2656
2656
  },
2657
2657
  "file_map": {
2658
- "115": {
2659
- "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch/mod.nr",
2658
+ "116": {
2659
+ "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
2660
+ "source": "use crate::{\n discovery::private_notes::MAX_NOTE_PACKED_LEN,\n macros::{\n dispatch::generate_public_dispatch,\n functions::{\n stub_registry,\n utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n },\n notes::{generate_note_export, NOTES},\n storage::STORAGE_LAYOUT_NAME,\n utils::{get_trait_impl_method, module_has_storage},\n },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The message discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_messages`, \n /// `do_process_log` and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform message discovery, resulting in new private notes, partial notes and events.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n // the unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n _first_nullifier_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let message_discovery_call = create_message_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $message_discovery_call\n }\n }\n}\n"
2661
+ },
2662
+ "117": {
2663
+ "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
2660
2664
  "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n let functions = m.functions();\n let functions =\n functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n let unit = get_type::<()>();\n\n let ifs = functions.map(|function: FunctionDefinition| {\n let name = function.name();\n let parameters = function.parameters();\n let return_type = function.return_type();\n\n let selector: Field = compute_fn_selector(function);\n\n let mut parameters_size = 0;\n for param in parameters {\n parameters_size += size_in_fields(param.1);\n }\n\n let initial_read = if parameters.len() == 0 {\n quote {}\n } else {\n // The initial calldata_copy offset is 1 to skip the Field selector\n // The expected calldata is the serialization of\n // - FunctionSelector: the selector of the function intended to dispatch\n // - Parameters: the parameters of the function intended to dispatch\n // That is, exactly what is expected for a call to the target function,\n // but with a selector added at the beginning.\n quote {\n let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n }\n };\n\n let parameter_index = &mut 0;\n let reads = parameters.map(|param: (Quoted, Type)| {\n let parameter_index_value = *parameter_index;\n let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n let param_type = param.1;\n let read = quote {\n let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n };\n *parameter_index += 1;\n quote { $read }\n });\n let read = reads.join(quote { });\n\n let mut args = &[];\n for parameter_index in 0..parameters.len() {\n let param_name = f\"arg{parameter_index}\".quoted_contents();\n args = args.push_back(quote { $param_name });\n }\n\n let args = args.join(quote { , });\n let call = quote { $name($args) };\n\n let return_code = if return_type == unit {\n quote {\n $call;\n // Force early return.\n dep::aztec::context::public_context::avm_return([]);\n }\n } else {\n quote {\n let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n dep::aztec::context::public_context::avm_return(return_value.as_slice());\n }\n };\n\n let if_ = quote {\n if selector == $selector {\n $initial_read\n $read\n $return_code\n }\n };\n if_\n });\n\n if ifs.len() == 0 {\n // No dispatch function if there are no public functions\n quote {}\n } else {\n let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n let dispatch = ifs.join(quote { });\n\n let body = quote {\n // We mark this as public because our whole system depends on public\n // functions having this attribute. However, the public MACRO will\n // handle the public_dispatch function specially and do nothing.\n #[public]\n pub unconstrained fn public_dispatch(selector: Field) {\n $dispatch\n }\n };\n\n body\n }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n let size = array_size_in_fields(typ);\n let size = size.or_else(|| bool_size_in_fields(typ));\n let size = size.or_else(|| constant_size_in_fields(typ));\n let size = size.or_else(|| field_size_in_fields(typ));\n let size = size.or_else(|| int_size_in_fields(typ));\n let size = size.or_else(|| str_size_in_fields(typ));\n let size = size.or_else(|| struct_size_in_fields(typ));\n let size = size.or_else(|| tuple_size_in_fields(typ));\n if size.is_some() {\n size.unwrap()\n } else {\n panic(f\"Can't determine size in fields of {typ}\")\n }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option<u32> {\n typ.as_array().and_then(|typ: (Type, Type)| {\n let (typ, element_size) = typ;\n element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option<u32> {\n if typ.is_bool() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option<u32> {\n if typ.is_field() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option<u32> {\n if typ.as_integer().is_some() {\n Option::some(1)\n } else {\n Option::none()\n }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option<u32> {\n typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option<u32> {\n typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option<u32> {\n typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n let struct_type = typ.0;\n let generics = typ.1;\n let mut size = 0;\n for field in struct_type.fields(generics) {\n size += size_in_fields(field.1);\n }\n size\n })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option<u32> {\n typ.as_tuple().map(|types: [Type]| {\n let mut size = 0;\n for typ in types {\n size += size_in_fields(typ);\n }\n size\n })\n}\n\ncomptime fn get_type<T>() -> Type {\n let t: T = std::mem::zeroed();\n std::meta::type_of(t)\n}\n"
2661
2665
  },
2662
- "122": {
2666
+ "124": {
2663
2667
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
2664
- "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform note discovery, since they may need to access notes. This is slightly inefficient\n // and could be improved by only doing it once we actually attempt to read any.\n let note_discovery_call = if NOTES.len() > 0 {\n create_note_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $note_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform note discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let note_discovery_call = if NOTES.len() > 0 {\n create_note_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $note_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_note_discovery_call() -> Quoted {\n quote {\n /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n /// safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_notes(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n"
2665
- },
2666
- "123": {
2667
- "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/mod.nr",
2668
- "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{\n stub_registry,\n utils::{create_note_discovery_call, find_and_transform_top_level_unconstrained_fns},\n};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n let interface = generate_contract_interface(m);\n\n find_and_transform_top_level_unconstrained_fns(m);\n\n let contract_library_method_compute_note_hash_and_nullifier =\n generate_contract_library_method_compute_note_hash_and_nullifier();\n let process_log = generate_process_log();\n let note_exports = generate_note_exports();\n let public_dispatch = generate_public_dispatch(m);\n let sync_notes = generate_sync_notes();\n\n quote {\n $note_exports\n $interface\n $contract_library_method_compute_note_hash_and_nullifier\n $process_log\n $public_dispatch\n $sync_notes\n }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n let module_name = m.name();\n let contract_stubs = stub_registry::get(m);\n let fn_stubs_quote = if contract_stubs.is_some() {\n contract_stubs.unwrap().join(quote {})\n } else {\n quote {}\n };\n\n let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n let storage_layout_getter = if has_storage_layout {\n let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n quote {\n pub fn storage_layout() -> StorageLayoutFields {\n $storage_layout_name.fields\n }\n }\n } else {\n quote {}\n };\n\n let library_storage_layout_getter = if has_storage_layout {\n quote {\n #[contract_library_method]\n $storage_layout_getter\n }\n } else {\n quote {}\n };\n\n quote {\n pub struct $module_name {\n pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n }\n\n impl $module_name {\n $fn_stubs_quote\n\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> Self {\n Self { target_contract: addr }\n }\n\n pub fn interface() -> Self {\n Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $storage_layout_getter\n }\n\n #[contract_library_method]\n pub fn at(\n addr: aztec::protocol_types::address::AztecAddress\n ) -> $module_name {\n $module_name { target_contract: addr }\n }\n\n #[contract_library_method]\n pub fn interface() -> $module_name {\n $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n }\n\n $library_storage_layout_getter\n\n }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n let max_note_packed_len = notes.fold(\n 0,\n |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n if len > acc {\n len\n } else {\n acc\n }\n },\n );\n\n if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n panic(\n f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n );\n }\n\n // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n let mut if_note_type_id_match_statements_list = &[];\n for i in 0..notes.len() {\n let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n let get_note_type_id = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteType },\n quote { get_id },\n );\n let unpack = get_trait_impl_method(\n typ,\n quote { crate::protocol_types::traits::Packable<_> },\n quote { unpack },\n );\n\n let compute_note_hash = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_note_hash },\n );\n\n let compute_nullifier_unconstrained = get_trait_impl_method(\n typ,\n quote { crate::note::note_interface::NoteHash },\n quote { compute_nullifier_unconstrained },\n );\n\n let if_or_else_if = if i == 0 {\n quote { if }\n } else {\n quote { else if }\n };\n\n if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n quote {\n $if_or_else_if note_type_id == $get_note_type_id() {\n // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n // unpack function on it.\n let expected_len = $packed_note_length;\n let actual_len = packed_note.len();\n assert(\n actual_len == expected_len,\n f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n );\n\n let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n let note_hash = $compute_note_hash(note, storage_slot);\n \n // The note discovery process finds settled notes, that is, notes that were created in prior\n // transactions and are therefore already part of the note hash tree. We therefore compute the\n // nullification note hash by treating the note as a settled note with the provided nonce.\n let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n aztec::note::retrieved_note::RetrievedNote{ \n note, \n contract_address, \n metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n }, \n storage_slot,\n );\n\n let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n Option::some(\n aztec::discovery::NoteHashAndNullifier {\n note_hash, inner_nullifier\n }\n )\n }\n },\n );\n }\n\n let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n quote {\n /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n /// tree with `nonce`.\n ///\n /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n /// and `attempt_note_discovery`.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n storage_slot: Field,\n note_type_id: Field,\n contract_address: aztec::protocol_types::address::AztecAddress,\n nonce: Field,\n ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n $if_note_type_id_match_statements\n else {\n Option::none()\n }\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n /// This contract does not use private notes, so this function should never be called as it will\n /// unconditionally fail.\n ///\n /// This function is automatically injected by the `#[aztec]` macro.\n #[contract_library_method]\n unconstrained fn _compute_note_hash_and_nullifier(\n _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n _storage_slot: Field,\n _note_type_id: Field,\n _contract_address: aztec::protocol_types::address::AztecAddress,\n _nonce: Field,\n ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n // and perform note discovery of either private notes or partial notes.\n // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n // that function.\n\n // We'll produce the entire body of the function in one go and then insert it into the function.\n let notes = NOTES.entries();\n\n if notes.len() > 0 {\n quote {\n unconstrained fn process_log(\n log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n // TODO(#10727): allow other contracts to process logs and deliver notes\n let contract_address = context.this_address();\n\n aztec::discovery::private_logs::do_process_log(\n contract_address,\n log_ciphertext,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n _compute_note_hash_and_nullifier,\n );\n }\n }\n } else {\n // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n // simply throws immediately.\n quote {\n unconstrained fn process_log(\n _log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n _tx_hash: Field,\n _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n _first_nullifier_in_tx: Field,\n _recipient: aztec::protocol_types::address::AztecAddress,\n ) {\n panic(f\"This contract does not use private notes\")\n }\n }\n }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n let notes = NOTES.values();\n // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n // generating partial note helper functions.\n notes\n .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n generate_note_export(s, note_type_id, fields)\n })\n .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n let note_discovery_call = create_note_discovery_call();\n quote {\n unconstrained fn sync_notes() {\n // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n // unconstrained execution context since it will not be available otherwise.\n let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n $note_discovery_call\n }\n }\n}\n"
2668
+ "source": "use crate::macros::{\n functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n notes::NOTES,\n utils::{\n add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n module_has_storage,\n },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n // Private Kernel Circuit.\n // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n // about the execution context (e.g. the caller).\n let original_params = f.parameters();\n f.set_parameters(&[(\n quote { inputs },\n quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n )]\n .append(original_params));\n\n let mut body = f.body().as_block().unwrap();\n\n // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n // the correct values.\n // TODO: Optimize args_hasher for small number of arguments\n let args_hasher_name = quote { args_hasher };\n let args_hasher = original_params.fold(\n quote {\n let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n },\n |args_hasher, param: (Quoted, Type)| {\n let (name, typ) = param;\n let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n quote {\n $args_hasher\n $appended_arg\n }\n },\n );\n\n let context_creation = quote {\n let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n // All private functions perform message discovery, since they may need to access notes. This is slightly\n // inefficient and could be improved by only doing it once we actually attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n // circuit expects.\n let return_value_var_name = quote { macro__returned__values };\n\n let return_value_type = f.return_type();\n let return_value = if body.len() == 0 {\n quote {}\n } else if return_value_type != type_of(()) {\n // The original return value is passed to a second args hasher which the context receives.\n let (body_without_return, last_body_expr) = body.pop_back();\n let return_value = last_body_expr.quoted();\n let return_value_assignment =\n quote { let $return_value_var_name: $return_value_type = $return_value; };\n let return_hasher_name = quote { return_hasher };\n let return_value_into_hasher =\n add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n body = body_without_return;\n\n quote {\n let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n $return_value_assignment\n $return_value_into_hasher\n context.set_return_hash($return_hasher_name);\n }\n } else {\n let (body_without_return, last_body_expr) = body.pop_back();\n if !last_body_expr.has_semicolon()\n & last_body_expr.as_for().is_none()\n & last_body_expr.as_assert().is_none()\n & last_body_expr.as_for_range().is_none()\n & last_body_expr.as_assert_eq().is_none()\n & last_body_expr.as_let().is_none() {\n let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n body = body_without_return.push_back(\n quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n );\n }\n quote {}\n };\n\n let context_finish = quote { context.finish() };\n\n let to_prepend = quote {\n $args_hasher\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n $message_discovery_call\n };\n\n let to_append = quote {\n $return_value\n $mark_as_initialized\n $context_finish\n };\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n f.set_return_type(\n quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n .as_type(),\n );\n f.set_return_data();\n\n fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n let fn_abi = create_fn_abi_export(f);\n let fn_stub = stub_fn(f);\n stub_registry::register(f.module(), fn_stub);\n\n // If a function is further modified as unconstrained, we throw an error\n if f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n );\n }\n\n let module_has_initializer = module_has_initializer(f.module());\n let module_has_storage = module_has_storage(f.module());\n\n // Public functions undergo a lot of transformations from their Aztec.nr form.\n let original_params = f.parameters();\n let args_len = original_params\n .map(|(name, typ): (Quoted, Type)| {\n generate_serialize_to_fields(name, typ, &[], false).0.len()\n })\n .fold(0, |acc: u32, val: u32| acc + val);\n\n // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n let context_creation = quote {\n let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n // We start from 1 because we skip the selector for the dispatch function.\n let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n dep::aztec::hash::hash_args_array(serialized_args)\n });\n };\n\n // Modifications introduced by the different marker attributes.\n let internal_check = if is_fn_internal(f) {\n create_internal_check(f)\n } else {\n quote {}\n };\n\n let view_check = if is_fn_view(f) {\n create_view_check(f)\n } else {\n quote {}\n };\n\n let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n } else {\n (quote {}, quote {})\n };\n\n let storage_init = if module_has_storage {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n quote {\n #[allow(unused_variables)]\n let storage = Storage::init(&mut context);\n }\n } else {\n quote {}\n };\n\n // Initialization checks are not included in contracts that don't have initializers.\n let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n create_init_check(f)\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $assert_initializer\n $init_check\n $internal_check\n $view_check\n $storage_init\n };\n\n let to_append = quote {\n $mark_as_initialized\n };\n\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, to_append);\n f.set_body(modified_body);\n\n // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n // bytecode.\n f.set_unconstrained(true);\n f.set_return_public(true);\n\n fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n // the fallback case for a function that matches no other rules.\n // TODO(#12743): improve this\n\n // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n !is_fn_private(f)\n & !is_fn_public(f)\n & !f.has_named_attribute(\"contract_library_method\")\n & !f.has_named_attribute(\"test\")\n });\n\n // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n // output of utils such as `nargo test --list-tests`.\n // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n // // #[private] macro, possibly resulting in a non-standard interface).\n // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n // !f.is_unconstrained()\n // }) {\n // let name = f.name();\n // warn(\n // f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n // );\n // }\n\n // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n // appropriate transformation. Ideally these would be explicitly designated as such instead.\n for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n f.is_unconstrained()\n }) {\n transform_top_level_unconstrained(f);\n }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n let storage_init = if module_has_storage {\n quote {\n // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n // referenced. We instead ignore 'unused variable' warnings for it.\n #[allow(unused_variables)]\n let storage = Storage::init(context);\n }\n } else {\n quote {}\n };\n\n // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n // attempt to read any.\n let message_discovery_call = if NOTES.len() > 0 {\n create_message_discovery_call()\n } else {\n quote {}\n };\n\n let to_prepend = quote {\n $context_creation\n $storage_init\n $message_discovery_call\n };\n let body = f.body().as_block().unwrap();\n let modified_body = modify_fn_body(body, to_prepend, quote {});\n f.set_return_public(true);\n f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called internally\";\n quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n let name = f.name();\n let assertion_message = f\"Function {name} can only be called statically\";\n if is_fn_private(f) {\n // Here `context` is of type context::PrivateContext\n quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n } else {\n // Here `context` is of type context::PublicContext\n quote { assert(context.is_static_call(), $assertion_message); }\n }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n let fn_visibility = get_fn_visibility(f);\n f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n quote {\n /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n /// always safe to call.\n unsafe {\n dep::aztec::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n"
2669
2669
  },
2670
- "125": {
2671
- "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage/mod.nr",
2670
+ "127": {
2671
+ "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
2672
2672
  "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n // This macro performs three things:\n // - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n // functions will have the storage variable injected and initialized via the `init` function.\n // - it implements said `init` function by allocating appropriate storage slots to each state variable.\n // - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n // macro.\n let mut slot: u32 = 1;\n let mut storage_vars_constructors = &[];\n let mut storage_layout_fields = &[];\n let mut storage_layout_constructors = &[];\n\n // TODO(#8658): uncomment the code below to inject the Context type parameter.\n //let mut new_storage_fields = &[];\n //let context_generic = s.add_generic(\"Context\");\n for field in s.fields_as_written() {\n // FIXME: This doesn't handle field types with generics\n let (name, typ) = field;\n let (storage_field_constructor, storage_size) =\n generate_storage_field_constructor(typ, quote { $slot }, false);\n storage_vars_constructors =\n storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n // a contract.\n storage_layout_fields =\n storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n storage_layout_constructors = storage_layout_constructors.push_back(\n quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n );\n //let with_context_generic = add_context_generic(typ, context_generic);\n //println(with_context_generic);\n //new_storage_fields = new_storage_fields.push_back((name, with_context_generic ));\n slot += storage_size;\n }\n\n //s.set_fields(new_storage_fields);\n let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n let storage_impl = quote {\n impl<Context> Storage<Context> {\n fn init(context: Context) -> Self {\n Self {\n $storage_vars_constructors\n }\n }\n }\n };\n\n let storage_layout_fields = storage_layout_fields.join(quote {,});\n let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n let module = s.module();\n let module_name = module.name();\n let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n let (module_name_str, module_name_len) = module_name.as_str_quote();\n STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n quote {\n $storage_impl\n\n pub struct StorageLayoutFields {\n $storage_layout_fields\n }\n\n pub struct StorageLayout<let N: u32> {\n pub contract_name: str<N>,\n pub fields: StorageLayoutFields\n }\n\n #[abi(storage)]\n pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n contract_name: $module_name_str,\n fields: StorageLayoutFields { $storage_layout_constructors }\n };\n }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n typ: Type,\n slot: Quoted,\n parent_is_map: bool,\n) -> (Quoted, u32) {\n assert(\n typ.as_data_type().is_some(),\n \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n );\n let (container_struct, generics) = typ.as_data_type().unwrap();\n let struct_name = container_struct.name();\n\n if is_storage_map(typ) {\n // Map state variables recursively initialize their contents - this includes nested maps.\n let (value_constructor, _) =\n generate_storage_field_constructor(generics[1], quote { slot }, true);\n (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n } else {\n let storage_size = if parent_is_map {\n // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n // in slots very far away from one another.\n 1\n } else {\n let (_, container_struct_generics) = typ.as_data_type().unwrap();\n let stored_struct = container_struct_generics[0];\n\n if is_note(stored_struct) {\n // Private notes always occupy a single slot, since the slot is only used as a state variable\n // identifier.\n 1\n } else {\n get_storage_size(typ)\n }\n };\n\n // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n (quote { $struct_name::new(context, $slot)}, storage_size)\n }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n if typ.as_data_type().is_some() {\n let (def, generics) = typ.as_data_type().unwrap();\n let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n let maybe_key = generics[0];\n let maybe_value = generics[1];\n let maybe_context = generics[2];\n quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n } else {\n quote {()}.as_type()\n };\n typ == maybe_map\n } else {\n false\n }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n let (def, mut generics) = typ.as_data_type().expect(\n f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n );\n let name = def.name();\n\n if is_storage_map(typ) {\n generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n generics[generics.len() - 1] = context_generic;\n } else {\n generics[generics.len() - 1] = context_generic;\n }\n\n let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n quote { $name<$generics> }.as_type()\n}\n"
2673
2673
  },
2674
- "143": {
2674
+ "145": {
2675
2675
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
2676
2676
  "source": "use dep::protocol_types::{\n abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _start_side_effect_counter: u32,\n _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n start_side_effect_counter: u32,\n is_static_call: bool,\n) -> (u32, Field) {\n let fields = call_private_function_oracle(\n contract_address,\n function_selector,\n args_hash,\n start_side_effect_counter,\n is_static_call,\n );\n\n let mut reader = Reader::new(fields);\n let end_side_effect_counter = reader.read_u32();\n let returns_hash = reader.read();\n\n (end_side_effect_counter, returns_hash)\n}\n"
2677
2677
  },
2678
- "144": {
2678
+ "146": {
2679
2679
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
2680
2680
  "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T, let N: u32>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n T: Serialize<N>,\n{\n let serialized = value.serialize();\n store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T, let N: u32>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n T: Deserialize<N>,\n{\n let serialized_option = load_oracle::<N>(contract_address, slot, N);\n serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {\n copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n contract_address: AztecAddress,\n slot: Field,\n values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n contract_address: AztecAddress,\n slot: Field,\n array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n contract_address: AztecAddress,\n src_slot: Field,\n dst_slot: Field,\n num_entries: u32,\n) {}\n\nmod test {\n // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n // oracles are hooked up correctly.\n\n use crate::{\n oracle::capsules::{copy, delete, load, store},\n test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n };\n use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n unconstrained fn setup() -> AztecAddress {\n let env = TestEnvironment::new();\n env.contract_address()\n }\n\n global SLOT: Field = 1;\n\n #[test]\n unconstrained fn stores_and_loads() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), value);\n }\n\n #[test]\n unconstrained fn store_overwrites() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n\n let new_value = MockStruct::new(7, 8);\n store(contract_address, SLOT, new_value);\n\n assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n }\n\n #[test]\n unconstrained fn loads_empty_slot() {\n let contract_address = setup();\n\n let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_stored_value() {\n let contract_address = setup();\n\n let value = MockStruct::new(5, 6);\n store(contract_address, SLOT, value);\n delete(contract_address, SLOT);\n\n let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn deletes_empty_slot() {\n let contract_address = setup();\n\n delete(contract_address, SLOT);\n let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n assert_eq(loaded_value, Option::none());\n }\n\n #[test]\n unconstrained fn copies_non_overlapping_values() {\n let contract_address = setup();\n\n let src = 5;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 10;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_src_ahead() {\n let contract_address = setup();\n\n let src = 1;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 2;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n }\n\n #[test]\n unconstrained fn copies_overlapping_values_with_dst_ahead() {\n let contract_address = setup();\n\n let src = 2;\n\n let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n store(contract_address, src, values[0]);\n store(contract_address, src + 1, values[1]);\n store(contract_address, src + 2, values[2]);\n\n let dst = 1;\n copy(contract_address, src, dst, 3);\n\n assert_eq(load(contract_address, dst).unwrap(), values[0]);\n assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n }\n\n #[test(should_fail_with = \"copy empty slot\")]\n unconstrained fn cannot_copy_empty_values() {\n let contract_address = setup();\n\n copy(contract_address, SLOT, SLOT, 1);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_store_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let value = MockStruct::new(5, 6);\n store(other_contract_address, SLOT, value);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_load_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n let _: Option<MockStruct> = load(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_delete_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n delete(other_contract_address, SLOT);\n }\n\n #[test(should_fail_with = \"not allowed to access\")]\n unconstrained fn cannot_copy_other_contract() {\n let contract_address = setup();\n let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n copy(other_contract_address, SLOT, SLOT, 0);\n }\n}\n"
2681
2681
  },
2682
- "145": {
2682
+ "147": {
2683
2683
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
2684
2684
  "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n enqueue_public_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n _contract_address: AztecAddress,\n _function_selector: FunctionSelector,\n _args_hash: Field,\n _side_effect_counter: u32,\n _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args_hash: Field,\n side_effect_counter: u32,\n is_static_call: bool,\n) -> Field {\n set_public_teardown_function_call_oracle(\n contract_address,\n function_selector,\n args_hash,\n side_effect_counter,\n is_static_call,\n )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
2685
2685
  },
2686
- "146": {
2686
+ "148": {
2687
2687
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
2688
2688
  "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n get_version_oracle()\n}\n"
2689
2689
  },
2690
- "147": {
2690
+ "149": {
2691
2691
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
2692
2692
  "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
2693
2693
  },
2694
- "157": {
2695
- "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/note_discovery.nr",
2696
- "source": "use crate::discovery::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec<Field, PUBLIC_LOG_DATA_SIZE_IN_FIELDS>,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option<LogWithTxData> {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option<LogWithTxData> {}\n"
2697
- },
2698
2694
  "158": {
2695
+ "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr",
2696
+ "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {\n deliver_note_oracle(\n contract_address,\n storage_slot,\n nonce,\n packed_note,\n note_hash,\n nullifier,\n tx_hash,\n recipient,\n )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n pub log_content: BoundedVec<Field, PUBLIC_LOG_DATA_SIZE_IN_FIELDS>,\n pub tx_hash: Field,\n /// The array of new note hashes created by `tx_hash`\n pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n /// The first nullifier created by `tx_hash`\n pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option<LogWithTxData> {\n get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n contract_address: AztecAddress,\n storage_slot: Field,\n nonce: Field,\n packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n note_hash: Field,\n nullifier: Field,\n tx_hash: Field,\n recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option<LogWithTxData> {}\n"
2697
+ },
2698
+ "160": {
2699
2699
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
2700
- "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n _nullifier: Field,\n _note_hash: Field,\n _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n let return_size = placeholder_fields.len() as u32;\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n return_size,\n placeholder_fields,\n )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n mut placeholder_opt_notes: [Option<RetrievedNote<Note>>; 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 _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter TODO(benesjan): try removing this.\n) -> [Option<RetrievedNote<Note>>; S]\nwhere\n Note: NoteType + Packable<N>,\n{\n let fields = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n placeholder_fields,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n for i in 0..placeholder_opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n placeholder_opt_notes[i] = Option::some(retrieved_note);\n };\n }\n placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n"
2700
+ "source": "use crate::{\n note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n notify_created_note_oracle_wrapper(\n storage_slot,\n note_type_id,\n packed_note,\n note_hash,\n counter,\n )\n };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n // call.\n unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n storage_slot: Field,\n note_type_id: Field,\n packed_note: [Field; N],\n note_hash: Field,\n counter: u32,\n) {\n notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n _storage_slot: Field,\n _note_type_id: Field,\n _packed_note: [Field; N],\n _note_hash: Field,\n _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n nullifier: Field,\n note_hash: Field,\n counter: u32,\n) {\n notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n _storage_slot: Field,\n _num_selects: u8,\n _select_by_indexes: [u8; N],\n _select_by_offsets: [u8; N],\n _select_by_lengths: [u8; N],\n _select_values: [Field; N],\n _select_comparators: [u8; N],\n _sort_by_indexes: [u8; N],\n _sort_by_offsets: [u8; N],\n _sort_by_lengths: [u8; N],\n _sort_order: [u8; N],\n _limit: u32,\n _offset: u32,\n _status: u8,\n _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; N],\n select_by_offsets: [u8; N],\n select_by_lengths: [u8; N],\n select_values: [Field; N],\n select_comparators: [u8; N],\n sort_by_indexes: [u8; N],\n sort_by_offsets: [u8; N],\n sort_by_lengths: [u8; N],\n sort_order: [u8; N],\n limit: u32,\n offset: u32,\n status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n // the oracle, so that it knows how big the return array must be.\n get_notes_oracle(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n ORACLE_RETURN_FIELD_LENGTH,\n )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let MAX_NOTES: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n storage_slot: Field,\n num_selects: u8,\n select_by_indexes: [u8; M],\n select_by_offsets: [u8; M],\n select_by_lengths: [u8; M],\n select_values: [Field; M],\n select_comparators: [u8; M],\n sort_by_indexes: [u8; M],\n sort_by_offsets: [u8; M],\n sort_by_lengths: [u8; M],\n sort_order: [u8; M],\n limit: u32,\n offset: u32,\n status: u8,\n _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n Note: NoteType + Packable<N>,\n{\n let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n storage_slot,\n num_selects,\n select_by_indexes,\n select_by_offsets,\n select_by_lengths,\n select_values,\n select_comparators,\n sort_by_indexes,\n sort_by_offsets,\n sort_by_lengths,\n sort_order,\n limit,\n offset,\n status,\n );\n let num_notes = fields[0] as u32;\n let contract_address = AztecAddress::from_field(fields[1]);\n\n let mut opt_notes = [Option::none(); MAX_NOTES];\n for i in 0..opt_notes.len() {\n if i < num_notes {\n // lengths named as per typescript.\n let return_header_length: u32 = 2; // num_notes & contract_address.\n let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n let maybe_nonce = fields[read_offset];\n let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n let packed_note = array::subarray(fields, read_offset + 2);\n\n let note = Note::unpack(packed_note);\n let retrieved_note = RetrievedNote {\n note,\n contract_address,\n metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n };\n\n opt_notes[i] = Option::some(retrieved_note);\n };\n }\n opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n sender: AztecAddress,\n recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe {\n increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n sender: AztecAddress,\n recipient: AztecAddress,\n) {\n increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n _sender: AztecAddress,\n _recipient: AztecAddress,\n) {}\n"
2701
2701
  },
2702
- "161": {
2702
+ "163": {
2703
2703
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
2704
2704
  "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n address: Field,\n storage_slot: Field,\n block_number: Field,\n length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> [Field; N] {\n storage_read_oracle(\n address.to_field(),\n storage_slot,\n block_number as Field,\n N as Field,\n )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n address: AztecAddress,\n storage_slot: Field,\n block_number: u32,\n) -> T\nwhere\n T: Packable<N>,\n{\n T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n use crate::oracle::storage::{raw_storage_read, storage_read};\n use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n use crate::test::mocks::mock_struct::MockStruct;\n use std::test::OracleMock;\n\n global address: AztecAddress = AztecAddress::from_field(29);\n global slot: Field = 7;\n global block_number: u32 = 17;\n\n #[test]\n unconstrained fn test_raw_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n assert_eq(read[0], 13);\n assert_eq(read[1], 42);\n }\n\n #[test]\n unconstrained fn test_storage_read() {\n let written = MockStruct { a: 13, b: 42 };\n\n let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n let read: MockStruct = storage_read(address, slot, block_number);\n assert_eq(read.a, 13);\n assert_eq(read.b, 42);\n }\n}\n"
2705
2705
  },
2706
- "163": {
2706
+ "165": {
2707
2707
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
2708
2708
  "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<N> for Map<K, T, Context>\nwhere\n T: Packable<N>,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n // docs:start:new\n pub fn new(\n context: Context,\n storage_slot: Field,\n state_var_constructor: fn(Context, Field) -> V,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n Map { context, storage_slot, state_var_constructor }\n }\n // docs:end:new\n\n // docs:start:at\n pub fn at(self, key: K) -> V\n where\n K: ToField,\n {\n // TODO(#1204): use a generator index for the storage slot\n let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\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"
2709
2709
  },
2710
- "171": {
2710
+ "173": {
2711
2711
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
2712
2712
  "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n context: Context,\n storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<N> for PublicMutable<T, Context>\nwhere\n T: Packable<N>,\n{\n fn get_storage_slot(self) -> Field {\n self.storage_slot\n }\n}\n\nimpl<T, Context> PublicMutable<T, Context> {\n // docs:start:public_mutable_struct_new\n pub fn new(\n // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n context: Context,\n storage_slot: Field,\n ) -> Self {\n assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n PublicMutable { context, storage_slot }\n }\n // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n T: Packable<T_PACKED_LEN>,\n{\n // docs:start:public_mutable_struct_read\n pub fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n // docs:end:public_mutable_struct_read\n\n // docs:start:public_mutable_struct_write\n pub fn write(self, value: T) {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n T: Packable<T_PACKED_LEN>,\n{\n pub unconstrained fn read(self) -> T {\n self.context.storage_read(self.storage_slot)\n }\n}\n"
2713
2713
  },
2714
- "185": {
2714
+ "187": {
2715
2715
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
2716
2716
  "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let A_LEN: u32, let B_LEN: u32, let DST_LEN: u32>(\n a: BoundedVec<T, A_LEN>,\n b: BoundedVec<T, B_LEN>,\n) -> BoundedVec<T, DST_LEN> {\n let mut dst = BoundedVec::new();\n\n dst.extend_from_bounded_vec(a);\n dst.extend_from_bounded_vec(b);\n\n dst\n}\n\nmod test {\n use super::append;\n\n #[test]\n unconstrained fn append_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::new();\n let b: BoundedVec<_, 14> = BoundedVec::new();\n\n let result: BoundedVec<Field, 5> = append(a, b);\n\n assert_eq(result.len(), 0);\n assert_eq(result.storage(), std::mem::zeroed());\n }\n\n #[test]\n unconstrained fn append_non_empty_vecs() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let result: BoundedVec<Field, 8> = append(a, b);\n\n assert_eq(result.len(), 6);\n assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n }\n\n #[test(should_fail_with = \"out of bounds\")]\n unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n let _: BoundedVec<Field, 5> = append(a, b);\n }\n}\n"
2717
2717
  },
2718
- "187": {
2718
+ "189": {
2719
2719
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr",
2720
2720
  "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec<T, let MaxLen: u32, Env>(\n vec: BoundedVec<T, MaxLen>,\n f: fn[Env](T, u32) -> (),\n) {\n for i in 0..vec.len() {\n f(vec.get_unchecked(i), i);\n }\n}\n"
2721
2721
  },
2722
- "188": {
2722
+ "190": {
2723
2723
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
2724
2724
  "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n src: [T; SRC_LEN],\n offset: u32,\n) -> [T; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n let mut dst: [T; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\nmod test {\n use super::subarray;\n\n #[test]\n unconstrained fn subarray_into_empty() {\n // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n assert_eq(subarray::<Field, _, _>([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n }\n\n #[test]\n unconstrained fn subarray_complete() {\n assert_eq(subarray::<Field, _, _>([], 0), []);\n assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n }\n\n #[test]\n unconstrained fn subarray_different_end_sizes() {\n // We implicitly select how many values to read in the size of the return array\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subarray_offset_too_large() {\n // With an offset of 1 we can only request up to 4 elements\n let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n }\n\n #[test(should_fail)]\n unconstrained fn subarray_bad_return_value() {\n assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n }\n}\n"
2725
2725
  },
2726
- "189": {
2726
+ "191": {
2727
2727
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
2728
2728
  "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n bvec: BoundedVec<T, SRC_MAX_LEN>,\n offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n // their original length.\n BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n use super::subbvec;\n\n #[test]\n unconstrained fn subbvec_empty() {\n let bvec = BoundedVec::<Field, 0>::from_array([]);\n assert_eq(subbvec(bvec, 0), bvec);\n }\n\n #[test]\n unconstrained fn subbvec_complete() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), bvec);\n\n let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 0), smaller_capacity);\n }\n\n #[test]\n unconstrained fn subbvec_partial() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n }\n\n #[test]\n unconstrained fn subbvec_into_empty() {\n let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_offset_past_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n }\n\n #[test(should_fail)]\n unconstrained fn subbvec_insufficient_dst_len() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n // for the capacity to reduce, but not the length (other than by len - offset).\n let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_causes_enlarge() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // subbvec does not supprt capacity increases\n let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n }\n\n #[test(should_fail_with = \"DST_LEN too large for offset\")]\n unconstrained fn subbvec_dst_len_too_large_for_offset() {\n let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n // which is less than 7.\n let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n }\n}\n"
2729
2729
  },
@@ -2731,43 +2731,43 @@
2731
2731
  "path": "std/hash/poseidon2.nr",
2732
2732
  "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n cache: [Field; 3],\n state: [Field; 4],\n cache_size: u32,\n squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n #[no_predicates]\n pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n Poseidon2::hash_internal(input, message_size, message_size != N)\n }\n\n pub fn new(iv: Field) -> Poseidon2 {\n let mut result =\n Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = crate::hash::poseidon2_permutation(self.state, 4);\n }\n\n fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal<let N: u32>(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let two_pow_64 = 18446744073709551616;\n let iv: Field = (in_len as Field) * two_pow_64;\n let mut sponge = Poseidon2::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n\npub struct Poseidon2Hasher {\n _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n fn finish(self) -> Field {\n let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n let mut sponge = Poseidon2::new(iv);\n for i in 0..self._state.len() {\n sponge.absorb(self._state[i]);\n }\n sponge.squeeze()\n }\n\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for Poseidon2Hasher {\n fn default() -> Self {\n Poseidon2Hasher { _state: &[] }\n }\n}\n"
2733
2733
  },
2734
- "261": {
2734
+ "263": {
2735
2735
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
2736
- "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
2736
+ "source": "use crate::{\n address::{\n partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n },\n constants::{\n AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n MAX_PROTOCOL_CONTRACTS,\n },\n contract_class_id::ContractClassId,\n hash::poseidon2_hash_with_separator,\n public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n fn eq(self, other: Self) -> bool {\n self.to_field() == other.to_field()\n }\n}\n\nimpl Empty for AztecAddress {\n fn empty() -> Self {\n Self { inner: 0 }\n }\n}\n\nimpl ToField for AztecAddress {\n fn to_field(self) -> Field {\n self.inner\n }\n}\n\nimpl FromField for AztecAddress {\n fn from_field(value: Field) -> AztecAddress {\n AztecAddress { inner: value }\n }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n [self.to_field()]\n }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n FromField::from_field(fields[0])\n }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n self.serialize()\n }\n\n fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n Self::deserialize(fields)\n }\n}\n\nimpl AztecAddress {\n pub fn zero() -> Self {\n Self { inner: 0 }\n }\n\n pub fn to_address_point(self) -> AddressPoint {\n // We compute the address point by taking our address, setting it to x, and then solving for y in the\n // equation which defines our bn curve:\n // y^2 = x^3 - 17; x = address\n let x = self.inner;\n let y_squared = pow(x, 3) - 17;\n\n // TODO (#8970): Handle cases where we cannot recover a point from an address\n let mut y = sqrt(y_squared);\n\n // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n // note: The field modulus is MAX_FIELD_VALUE + 1\n if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n y = (MAX_FIELD_VALUE + 1) - y;\n }\n\n AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n }\n\n pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n let public_keys_hash = public_keys.hash();\n\n let pre_address = poseidon2_hash_with_separator(\n [public_keys_hash.to_field(), partial_address.to_field()],\n GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n );\n\n let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n public_keys.ivpk_m.to_point(),\n );\n\n // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n AztecAddress::from_field(address_point.x)\n }\n\n pub fn compute_from_class_id(\n contract_class_id: ContractClassId,\n salted_initialization_hash: SaltedInitializationHash,\n public_keys: PublicKeys,\n ) -> Self {\n let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n contract_class_id,\n salted_initialization_hash,\n );\n\n AztecAddress::compute(public_keys, partial_address)\n }\n\n pub fn is_protocol_contract(self) -> bool {\n self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n }\n\n pub fn is_zero(self) -> bool {\n self.inner == 0\n }\n\n pub fn assert_is_zero(self) {\n assert(self.to_field() == 0);\n }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n let public_keys = PublicKeys {\n npk_m: NpkM {\n inner: Point {\n x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n is_infinite: false,\n },\n },\n ivpk_m: IvpkM {\n inner: Point {\n x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n is_infinite: false,\n },\n },\n ovpk_m: OvpkM {\n inner: Point {\n x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n is_infinite: false,\n },\n },\n tpk_m: TpkM {\n inner: Point {\n x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n is_infinite: false,\n },\n },\n };\n\n let partial_address = PartialAddress::from_field(\n 0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n );\n\n let address = AztecAddress::compute(public_keys, partial_address);\n\n // The following value was generated by `derivation.test.ts`.\n // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n let expected_computed_address_from_partial_and_pubkeys =\n 0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n let expected_computed_preaddress_from_partial_and_pubkey =\n 0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n let address = AztecAddress { inner: 37 };\n assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n let address = AztecAddress { inner: 37 };\n assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
2737
2737
  },
2738
- "278": {
2738
+ "280": {
2739
2739
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
2740
2740
  "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n/// debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n/// debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n/// debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n // to call.\n unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n msg: str<M>,\n args: [Field; N],\n) {\n debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
2741
2741
  },
2742
- "279": {
2742
+ "281": {
2743
2743
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
2744
2744
  "source": "use crate::{\n abis::{\n contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n contract_class_log::ContractClassLog,\n function_selector::FunctionSelector,\n note_hash::ScopedNoteHash,\n nullifier::ScopedNullifier,\n private_log::{PrivateLog, PrivateLogData},\n side_effect::{OrderedValue, scoped::Scoped},\n },\n address::{AztecAddress, EthAddress},\n constants::{\n FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n },\n merkle_tree::root::root_from_sibling_path,\n messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n poseidon2::Poseidon2Sponge,\n traits::{FromField, Hash, ToField},\n utils::{\n arrays::{array_concat, unsafe_padded_array_length},\n field::{field_from_bytes, field_from_bytes_32_trunc},\n },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n let sha256_hashed = sha256::digest(bytes_to_hash);\n let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n selector: FunctionSelector,\n vk_hash: Field,\n function_leaf_index: Field,\n function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n let function_leaf = function_leaf_preimage.hash();\n root_from_sibling_path(\n function_leaf,\n function_leaf_index,\n function_leaf_sibling_path,\n )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n // unique).\n poseidon2_hash_with_separator(\n [first_nullifier_in_tx, note_index_in_tx as Field],\n GENERATOR_INDEX__NOTE_HASH_NONCE,\n )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n let inputs = [nonce, siloed_note_hash];\n poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), note_hash],\n GENERATOR_INDEX__SILOED_NOTE_HASH,\n )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n siloed_note_hash: Field,\n first_nullifier: Field,\n note_index_in_tx: u32,\n) -> Field {\n if siloed_note_hash == 0 {\n 0\n } else {\n let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n compute_unique_note_hash(nonce, siloed_note_hash)\n }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n if note_hash.contract_address.is_zero() {\n 0\n } else {\n compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n poseidon2_hash_with_separator(\n [app.to_field(), nullifier],\n GENERATOR_INDEX__OUTER_NULLIFIER,\n )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n if nullifier.contract_address.is_zero() {\n nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n } else {\n compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n if private_log.contract_address.is_zero() {\n private_log.inner.log\n } else {\n let mut fields = private_log.inner.log.fields;\n fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n PrivateLog { fields }\n }\n}\n\nfn compute_siloed_contract_class_log_field(\n contract_address: AztecAddress,\n first_field: Field,\n) -> Field {\n poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n if contract_class_log.contract_address.is_zero() {\n contract_class_log\n } else {\n let mut log = contract_class_log;\n log.log.fields[0] = compute_siloed_contract_class_log_field(\n contract_class_log.contract_address,\n log.log.fields[0],\n );\n log\n }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n let array = contract_class_log.log.fields;\n // Safety: The below length is constrained in the base rollup.\n let length = unsafe { unsafe_padded_array_length(array) };\n if length == 0 {\n 0\n } else {\n poseidon2_hash(array)\n }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n contract_address: AztecAddress,\n recipient: EthAddress,\n content: Field,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n let mut bytes: [u8; 160] = std::mem::zeroed();\n\n let inputs =\n [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n for i in 0..5 {\n // TODO are bytes be in fr.to_buffer() ?\n let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n for j in 0..32 {\n bytes[32 * i + j] = item_bytes[j];\n }\n }\n\n sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n msg: ScopedL2ToL1Message,\n rollup_version_id: Field,\n chain_id: Field,\n) -> Field {\n if msg.contract_address.is_zero() {\n 0\n } else {\n compute_l2_to_l1_hash(\n msg.contract_address,\n msg.message.recipient,\n msg.message.content,\n rollup_version_id,\n chain_id,\n )\n }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n // This is a note about the cpp code, since it takes an array of Fields\n // instead of a u128.\n // 4 Field elements when converted to bytes will usually\n // occupy 4 * 32 = 128 bytes.\n // However, this function is making the assumption that each Field\n // only occupies 128 bits.\n //\n // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n // Concatentate two fields into 32x2 = 64 bytes\n // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n let mut hash_input_flattened = [0; 64];\n for offset in 0..input.len() {\n let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n for byte_index in 0..32 {\n hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n }\n }\n\n sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n T: ToField,\n{\n let inputs_with_separator = array_concat([separator.to_field()], inputs);\n poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if in_len != N {\n sponge.absorb(1);\n }\n sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n// - absorb normally up to 2 times to set cache_size to 1\n// - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n// - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n input: [Field; N],\n in_len: u32,\n variable: bool,\n) -> Poseidon2Sponge {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n // since we cannot isolate computation branches. The below is just to avoid that.\n let shift = if in_len == 0 { 0 } else { 1 };\n if in_len != 0 {\n // cache_size = 0, init absorb\n sponge.cache[0] = input[0];\n sponge.cache_size = 1;\n // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n // max_remainder = (N - 1) % 3;\n // max_chunks = (N - 1 - max_remainder) / 3;\n sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n sponge,\n input,\n in_len,\n variable,\n shift,\n );\n }\n sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n skip_0_check: bool,\n) -> Poseidon2Sponge {\n let mut sponge = in_sponge;\n // 'shift' is to account for already added inputs\n let mut shift = 0;\n // 'stop' is to avoid an underflow when inputting in_len = 0\n let mut stop = false;\n for i in 0..3 {\n if shift == in_len {\n stop = true;\n }\n if (sponge.cache_size != 1) & (!stop) {\n sponge.absorb(input[i]);\n shift += 1;\n }\n }\n sponge = if stop {\n sponge\n } else {\n // max_chunks = (N - (N % 3)) / 3;\n poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n sponge,\n input,\n in_len,\n skip_0_check,\n shift,\n )\n };\n sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n in_sponge: Poseidon2Sponge,\n input: [Field; N],\n in_len: u32,\n variable: bool,\n shift: u32,\n) -> Poseidon2Sponge {\n assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n // The below avoids an overflow\n let skip_last = 3 * M == N;\n // Writing in_sponge: &mut does not compile\n let mut sponge = in_sponge;\n let mut should_add = true;\n // The num of things left over after absorbing in 3s\n let remainder = (in_len - shift) % 3;\n // The num of chunks of 3 to absorb (maximum M)\n let chunks = (in_len - shift - remainder) / 3;\n for i in 0..M {\n // Now we loop through cache size = 1 -> 3\n should_add &= i != chunks;\n // This is the index at the start of the chunk (for readability)\n let k = 3 * i + shift;\n if should_add {\n // cache_size = 1, 2 => just assign\n sponge.cache[1] = input[k];\n sponge.cache[2] = input[k + 1];\n // cache_size = 3 => duplex + perm\n for j in 0..3 {\n sponge.state[j] += sponge.cache[j];\n }\n sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n sponge.cache[0] = input[k + 2];\n // cache_size is now 1 again, repeat loop\n } else if (!variable) & (i != chunks) {\n // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n let last_0 = if (i == M - 1) & (skip_last) {\n 0\n } else {\n input[k + 2]\n };\n let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n assert(all_0, \"Found non-zero field after breakpoint\");\n }\n }\n // we have 'remainder' num of items left to absorb\n should_add = true;\n // below is to avoid overflows (i.e. if inlen is close to N)\n let mut should_check = !variable;\n for i in 0..3 {\n should_add &= i != remainder;\n should_check &= in_len - remainder + i != N;\n if should_add {\n // we want to absorb the final 'remainder' items\n sponge.absorb(input[in_len - remainder + i]);\n } else if should_check {\n assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n }\n }\n sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n T: ToField,\n{\n let in_len = inputs.len() + 1;\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n sponge.absorb(separator.to_field());\n\n for i in 0..inputs.len() {\n sponge.absorb(inputs[i]);\n }\n\n sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n let mut fields = [0; (N + 30) / 31];\n let mut field_index = 0;\n let mut current_field = [0; 31];\n for i in 0..inputs.len() {\n let index = i % 31;\n current_field[index] = inputs[i];\n if index == 30 {\n fields[field_index] = field_from_bytes(current_field, false);\n current_field = [0; 31];\n field_index += 1;\n }\n }\n if field_index != fields.len() {\n fields[field_index] = field_from_bytes(current_field, false);\n }\n poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n for i in 0..in_len {\n input[i] = 3;\n }\n let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n let in_len = 501;\n let mut input: [Field; 4096] = [0; 4096];\n let mut fixed_input = [3; 501];\n assert(in_len == fixed_input.len()); // sanity check\n for i in 0..in_len {\n input[i] = 3;\n }\n // absorb 250 of the 501 things\n let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n let in_len = 0;\n let mut input: [Field; 4096] = [0; 4096];\n let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n let mut first_sponge =\n poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n let full_buffer = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n ];\n let result = sha256_to_field(full_buffer);\n\n assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n let result_bytes = sha256::digest(full_buffer);\n let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n assert(truncated_field == result);\n let mod_res = result + (result_bytes[31] as Field);\n assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n // All zeroes\n let hash_result =\n compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n // Non-zero case\n let hash_result = compute_l2_to_l1_hash(\n AztecAddress::from_field(1),\n EthAddress::from_field(3),\n 5,\n 2,\n 4,\n );\n assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n let version = 4;\n let chainId = 5;\n\n let hash = silo_l2_to_l1_message(\n ScopedL2ToL1Message {\n message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n contract_address: AztecAddress::from_field(3),\n },\n version,\n chainId,\n );\n\n // The following value was generated by `l2_to_l1_message.test.ts`\n let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n assert_eq(hash, hash_from_typescript);\n}\n"
2745
2745
  },
2746
- "293": {
2746
+ "295": {
2747
2747
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
2748
2748
  "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n typ: Type,\n target_trait: Quoted,\n target_method: Quoted,\n) -> TypedExpr {\n let trait_constraint = target_trait.as_trait_constraint();\n typ\n .get_trait_impl(trait_constraint)\n .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n .methods()\n .filter(|m| m.name() == target_method)[0]\n .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n/// value: u128,\n/// owner: AztecAddress,\n/// randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n/// inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n/// value: fields[0] as u128,\n/// owner: AztecAddress {\n/// inner: fields[1],\n/// },\n/// randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n/// the result we get is:\n/// ```\n/// UintNote {\n/// value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n/// owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n/// randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n name: Quoted,\n typ: Type,\n field_array_name: Quoted,\n num_already_consumed: u32,\n should_unpack: bool,\n) -> (Quoted, u32) {\n let mut result = quote {};\n // Counter for the number of fields consumed\n let mut consumed_counter: u32 = 0;\n\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_unpack & typ.implements(packable_constraint)) {\n // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We copy the packed fields into a new array and pass that to the unpack function in a quote\n let mut packed_fields_quotes = &[];\n for i in 0..packed_len {\n let index_in_field_array = i + num_already_consumed;\n packed_fields_quotes =\n packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n }\n let packed_fields = packed_fields_quotes.join(quote {,});\n\n // Now we call unpack on the type\n let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n result = quote { $unpack_method([ $packed_fields ]) };\n\n consumed_counter = packed_len;\n } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n // The field is a primitive so we just reference it in the field array\n result = quote { $field_array_name[$num_already_consumed] as $typ };\n consumed_counter = 1;\n } else if typ.as_data_type().is_some() {\n // The field is a struct so we iterate over each struct field and recursively call\n // `generate_deserialize_from_fields`\n let (nested_def, generics) = typ.as_data_type().unwrap();\n let nested_name = nested_def.name();\n let mut deserialized_fields_list = &[];\n\n // Iterate over each field in the struct\n for field in nested_def.fields(generics) {\n let (field_name, field_type) = field;\n // Recursively call `generate_deserialize_from_fields` for each field in the struct\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n field_name,\n field_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n deserialized_fields_list =\n deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n }\n\n // We can construct the struct from the deserialized fields\n let deserialized_fields = deserialized_fields_list.join(quote {,});\n result = quote {\n $nested_name {\n $deserialized_fields\n }\n };\n } else if typ.as_array().is_some() {\n // The field is an array so we iterate over each element and recursively call\n // `generate_deserialize_from_fields`\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n let mut array_fields_list = &[];\n\n // Iterate over each element in the array\n for _ in 0..array_len {\n // Recursively call `generate_deserialize_from_fields` for each element in the array\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n element_type,\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n // We increment the consumed counter by the number of fields consumed in the recursion\n consumed_counter += num_consumed_in_recursion;\n // We add the deserialized field to the list of deserialized fields.\n array_fields_list = array_fields_list.push_back(deserialized_field);\n }\n\n // We can construct the array from the deserialized fields\n let array_fields = array_fields_list.join(quote {,});\n result = quote { [ $array_fields ] };\n } else if typ.as_str().is_some() {\n // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n // to `generate_deserialize_from_fields`.\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let mut byte_list = &[];\n\n // Iterate over each character in the string\n for _ in 0..str_len {\n // Recursively call `generate_deserialize_from_fields` for each character in the string\n let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n name,\n quote {u8}.as_type(),\n field_array_name,\n consumed_counter + num_already_consumed,\n should_unpack,\n );\n\n // We should consume just one field in the recursion so we sanity check that\n assert_eq(\n num_consumed_in_recursion,\n 1,\n \"Incorrect number of fields consumed in string deserialization\",\n );\n\n // We increment the consumed counter by 1 as we have consumed one field\n consumed_counter += 1;\n\n // We add the deserialized field to the list of deserialized fields.\n // E.g. `fields[6] as u8`\n byte_list = byte_list.push_back(deserialized_field);\n }\n\n // We construct the string from the deserialized fields\n let bytes = byte_list.join(quote {,});\n result = quote { [ $bytes ].as_str_unchecked() };\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n\n (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n/// a: Field,\n/// b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n/// m1: MockStruct,\n/// m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n/// value: u128,\n/// value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n name: Quoted,\n typ: Type,\n omit: [Quoted],\n should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n let mut fields = &[];\n let mut aux_vars = &[];\n\n // Proceed if none of the omit rules omits this name\n if !omit.any(|to_omit| to_omit == name) {\n // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n let packable_constraint =\n quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n if (should_pack & typ.implements(packable_constraint)) {\n // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n // method, add the resulting field array to `aux_vars` and each field to `fields`.\n let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n let name_at_one_token = collapse_to_one_token(name);\n let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n // We add the individual fields to the fields array\n let pack_method = get_trait_impl_method(\n typ,\n quote { crate::traits::Packable<$packed_len> },\n quote { pack },\n );\n let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n for i in 0..packed_len {\n fields = fields.push_back(quote { $packed_struct_name[$i] });\n }\n\n // We add the new auxiliary variable to the aux_vars array\n aux_vars = aux_vars.push_back(packed_struct);\n } else if typ.is_field() {\n // For field we just add the value to fields\n fields = fields.push_back(name);\n } else if typ.as_integer().is_some() | typ.is_bool() {\n // For integer and bool we just cast to Field and add the value to fields\n fields = fields.push_back(quote { $name as Field });\n } else if typ.as_data_type().is_some() {\n // For struct we pref\n let nested_struct = typ.as_data_type().unwrap();\n let params = nested_struct.0.fields(nested_struct.1);\n let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n let maybe_prefixed_name = if name == quote {} {\n // Triggered when the param name is of a value available in the current scope (e.g. a function\n // argument) --> then we don't prefix the name with anything.\n param_name\n } else {\n // Triggered when we want to prefix the param name with the `name` from function input. This\n // can typically be `self` when implementing a method on a struct.\n quote { $name.$param_name }\n };\n generate_serialize_to_fields(\n quote {$maybe_prefixed_name},\n param_type,\n omit,\n should_pack,\n )\n });\n let struct_flattened_fields = struct_flattened.fold(\n &[],\n |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n );\n let struct_flattened_aux_vars = struct_flattened.fold(\n &[],\n |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n );\n fields = fields.append(struct_flattened_fields);\n aux_vars = aux_vars.append(struct_flattened_aux_vars);\n } else if typ.as_array().is_some() {\n // For array we recursively call `generate_serialize_to_fields(...)` for each element\n let (element_type, array_len) = typ.as_array().unwrap();\n let array_len = array_len.as_constant().unwrap();\n for i in 0..array_len {\n let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n quote { $name[$i] },\n element_type,\n omit,\n should_pack,\n );\n fields = fields.append(element_fields);\n aux_vars = aux_vars.append(element_aux_vars);\n }\n } else if typ.as_str().is_some() {\n // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n // then we add each byte to fields as a Field\n let length_type = typ.as_str().unwrap();\n let str_len = length_type.as_constant().unwrap();\n let as_member = name.as_expr().unwrap().as_member_access();\n let var_name = if as_member.is_some() {\n as_member.unwrap().1\n } else {\n name\n };\n let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n for i in 0..str_len {\n fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n }\n aux_vars = aux_vars.push_back(as_bytes);\n } else {\n panic(\n f\"Unsupported type for serialization of argument {name} and type {typ}\",\n )\n }\n }\n (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n let tokens = q.tokens();\n\n let mut single_token = quote {};\n for token in tokens {\n let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n quote {_}\n } else {\n token\n };\n single_token = f\"{single_token}{new_token}\".quoted_contents();\n }\n single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let aux_vars_for_serialization = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let field_serializations = fields.join(quote {,});\n let serialized_len = fields.len();\n quote {\n impl Serialize<$serialized_len> for $typ {\n fn serialize(self) -> [Field; $serialized_len] {\n $aux_vars_for_serialization\n [ $field_serializations ]\n }\n }\n }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n let typ = s.as_type();\n let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n let serialized_len = fields.len();\n let (deserialized, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n quote {\n impl Deserialize<$serialized_len> for $typ {\n fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n $deserialized\n }\n }\n }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n let packing_enabled = true;\n\n let typ = s.as_type();\n let (fields, aux_vars) =\n generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n let aux_vars_for_packing = if aux_vars.len() > 0 {\n let joint = aux_vars.join(quote {;});\n quote { $joint; }\n } else {\n quote {}\n };\n\n let (unpacked, _) =\n generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n let field_packings = fields.join(quote {,});\n let packed_len = fields.len();\n let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n (\n quote {\n impl $packable_trait for $typ {\n fn pack(self) -> [Field; $packed_len] {\n $aux_vars_for_packing\n [ $field_packings ]\n }\n\n fn unpack(packed: [Field; $packed_len]) -> Self {\n $unpacked\n }\n }\n },\n packed_len,\n )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n a: Field,\n b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n a: [Field; 2],\n b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n a: Smol,\n b: [Field; 2],\n c: [u8; 3],\n d: str<16>,\n}\n\nfn main() {\n assert(false);\n}\n\n#[test]\nfn smol_test() {\n let smol = Smol { a: 1, b: 2 };\n let serialized = smol.serialize();\n assert(serialized == [1, 2], serialized);\n let deserialized = Smol::deserialize(serialized);\n assert(deserialized == smol);\n\n // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n let packed = smol.pack();\n assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n let has_array = HasArray { a: [1, 2], b: true };\n let serialized = has_array.serialize();\n assert(serialized == [1, 2, 1], serialized);\n let deserialized = HasArray::deserialize(serialized);\n assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n let fancier =\n Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n let serialized = fancier.serialize();\n assert(\n serialized\n == [\n 1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n 0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n ],\n serialized,\n );\n let deserialized = Fancier::deserialize(serialized);\n assert(deserialized == fancier);\n}\n"
2749
2749
  },
2750
- "296": {
2750
+ "298": {
2751
2751
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
2752
2752
  "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n pub cache: [Field; 3],\n pub state: [Field; 4],\n pub cache_size: u32,\n pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n #[no_predicates]\n pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n }\n\n pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n let mut result =\n Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n result.state[RATE] = iv;\n result\n }\n\n fn perform_duplex(&mut self) {\n // add the cache into sponge state\n for i in 0..RATE {\n // We effectively zero-pad the cache by only adding to the state\n // cache that is less than the specified `cache_size`\n if i < self.cache_size {\n self.state[i] += self.cache[i];\n }\n }\n self.state = std::hash::poseidon2_permutation(self.state, 4);\n }\n\n pub fn absorb(&mut self, input: Field) {\n assert(!self.squeeze_mode);\n if self.cache_size == RATE {\n // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n self.perform_duplex();\n self.cache[0] = input;\n self.cache_size = 1;\n } else {\n // If we're absorbing, and the cache is not full, add the input into the cache\n self.cache[self.cache_size] = input;\n self.cache_size += 1;\n }\n }\n\n pub fn squeeze(&mut self) -> Field {\n assert(!self.squeeze_mode);\n // If we're in absorb mode, apply sponge permutation to compress the cache.\n self.perform_duplex();\n self.squeeze_mode = true;\n\n // Pop one item off the top of the permutation and return it.\n self.state[0]\n }\n\n fn hash_internal<let N: u32>(\n input: [Field; N],\n in_len: u32,\n is_variable_length: bool,\n ) -> Field {\n let iv: Field = (in_len as Field) * TWO_POW_64;\n let mut sponge = Poseidon2Sponge::new(iv);\n for i in 0..input.len() {\n if i < in_len {\n sponge.absorb(input[i]);\n }\n }\n\n // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n // fixed-length and variable-length hashes do not collide)\n if is_variable_length {\n sponge.absorb(1);\n }\n sponge.squeeze()\n }\n}\n"
2753
2753
  },
2754
- "316": {
2754
+ "318": {
2755
2755
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
2756
2756
  "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n K: ToField,\n{\n poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n #[test]\n fn test_derive_storage_slot_in_map_matches_typescript() {\n let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n let key = AztecAddress::from_field(\n 0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n );\n\n let slot = derive_storage_slot_in_map(map_slot, key);\n\n // The following value was generated by `map_slot.test.ts`\n let slot_from_typescript =\n 0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n assert_eq(slot, slot_from_typescript);\n }\n}\n"
2757
2757
  },
2758
- "334": {
2758
+ "336": {
2759
2759
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
2760
2760
  "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable<BOOL_PACKED_LEN> for bool {\n fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Packable<U8_PACKED_LEN> for u8 {\n fn pack(self) -> [Field; U8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Packable<U16_PACKED_LEN> for u16 {\n fn pack(self) -> [Field; U16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Packable<U32_PACKED_LEN> for u32 {\n fn pack(self) -> [Field; U32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Packable<U64_PACKED_LEN> for u64 {\n fn pack(self) -> [Field; U64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Packable<U128_PACKED_LEN> for u128 {\n fn pack(self) -> [Field; U128_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Packable<FIELD_PACKED_LEN> for Field {\n fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n [self]\n }\n\n fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Packable<I8_PACKED_LEN> for i8 {\n fn pack(self) -> [Field; I8_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Packable<I16_PACKED_LEN> for i16 {\n fn pack(self) -> [Field; I16_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Packable<I32_PACKED_LEN> for i32 {\n fn pack(self) -> [Field; I32_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Packable<I64_PACKED_LEN> for i64 {\n fn pack(self) -> [Field; I64_PACKED_LEN] {\n [self as Field]\n }\n\n fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl<T, let N: u32, let M: u32> Packable<N * M> for [T; N]\nwhere\n T: Packable<M>,\n{\n fn pack(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].pack();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n\n fn unpack(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::<T, M, N>(Packable::unpack, result)\n }\n}\n\n#[test]\nfn test_u16_packing() {\n let a: u16 = 10;\n assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n let a: i8 = -10;\n assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n let a: i16 = -10;\n assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n let a: i32 = -10;\n assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n let a: i64 = -10;\n assert_eq(a, i64::unpack(a.pack()));\n}\n"
2761
2761
  },
2762
- "335": {
2762
+ "337": {
2763
2763
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
2764
2764
  "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n fields[0] as bool\n }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n fields[0] as u8\n }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n fields[0] as u16\n }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n fields[0] as u32\n }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n fields[0] as u64\n }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for u128 {\n fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for u128 {\n fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n fields[0] as u128\n }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n [self]\n }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n fields[0]\n }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n fields[0] as i8\n }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n fields[0] as i16\n }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n fields[0] as i32\n }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n [self as Field]\n }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n fields[0] as i64\n }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n T: Serialize<M>,\n{\n fn serialize(self) -> [Field; N * M] {\n let mut result: [Field; N * M] = std::mem::zeroed();\n let mut serialized: [Field; M] = std::mem::zeroed();\n for i in 0..N {\n serialized = self[i].serialize();\n for j in 0..M {\n result[i * M + j] = serialized[j];\n }\n }\n result\n }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n T: Deserialize<M>,\n{\n fn deserialize(fields: [Field; N * M]) -> Self {\n let mut reader = crate::utils::reader::Reader::new(fields);\n let mut result: [T; N] = std::mem::zeroed();\n reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n }\n}\n\n#[test]\nfn test_u16_serialization() {\n let a: u16 = 10;\n assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n let a: i8 = -10;\n assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n let a: i16 = -10;\n assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n let a: i32 = -10;\n assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n let a: i64 = -10;\n assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
2765
2765
  },
2766
- "351": {
2766
+ "353": {
2767
2767
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
2768
2768
  "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n assert_exposed_sorted_transformed_value_array,\n get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n assert_split_sorted_transformed_value_arrays_asc,\n assert_split_sorted_transformed_value_arrays_desc,\n get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n src: [Field; SRC_LEN],\n offset: u32,\n) -> [Field; DST_LEN] {\n assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n for i in 0..DST_LEN {\n dst[i] = src[i + offset];\n }\n\n dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n T: Empty + Eq,\n{\n let len = array_length(array);\n BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n array: [T; N],\n find: fn[Env](T) -> bool,\n) -> u32 {\n let mut index = N;\n for i in 0..N {\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & find(array[i]) {\n index = i;\n }\n }\n index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut seen_empty = false;\n let mut length = 0;\n for i in 0..N {\n if is_empty(array[i]) {\n seen_empty = true;\n } else {\n assert(seen_empty == false, \"invalid array\");\n length += 1;\n }\n }\n length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // We get the length by checking the index of the first empty element.\n\n // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n // of the element and non-emptiness of the previous element is checked below.\n let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n if length != 0 {\n assert(!is_empty(array[length - 1]));\n }\n if length != N {\n assert(is_empty(array[length]));\n }\n length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n let mut result = [array1[0]; N + M];\n for i in 1..N {\n result[i] = array1[i];\n }\n for i in 0..M {\n result[i + N] = array2[i];\n }\n result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n // Safety: we constrain this array below\n let result = unsafe { array_merge_helper(array1, array2) };\n // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n let array1_len = array_length(array1);\n let mut add_from_left = true;\n for i in 0..N {\n add_from_left &= i != array1_len;\n if add_from_left {\n assert_eq(result[i], array1[i]);\n } else {\n assert_eq(result[i], array2[i - array1_len]);\n }\n }\n result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n T: Empty + Eq,\n{\n let mut result: [T; N] = [T::empty(); N];\n let mut i = 0;\n for elem in array1 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n for elem in array2 {\n if !is_empty(elem) {\n result[i] = elem;\n i += 1;\n }\n }\n result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n T: Empty,\n{\n assert(M + offset <= N, \"Subarray length larger than array length\");\n let mut result: [T; M] = [T::empty(); M];\n for i in 0..M {\n result[i] = array[offset + i];\n }\n result\n}\n\npub fn check_permutation<T, let N: u32>(\n original_array: [T; N],\n permuted_array: [T; N],\n original_indexes: [u32; N],\n)\nwhere\n T: Eq + Empty,\n{\n let mut seen_value = [false; N];\n for i in 0..N {\n let index = original_indexes[i];\n let original_value = original_array[index];\n assert(permuted_array[i].eq(original_value), \"Invalid index\");\n assert(!seen_value[index], \"Duplicated index\");\n seen_value[index] = true;\n }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let mut index = N;\n for i in 0..N {\n let j = N - i - 1;\n // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n if (index == N) & !is_empty(array[j]) {\n index = j;\n }\n }\n index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n let index = find_last_value_index(array);\n if index == N {\n 0\n } else {\n index + 1\n }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n T: Empty + Eq,\n{\n // Safety: this value is constrained in the below loop.\n let length = unsafe { unsafe_padded_array_length(array) };\n // Check the elt just before length is non-zero:\n if length != 0 {\n assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n }\n // Check all beyond length are zero:\n let mut check_zero = false;\n for i in 0..N {\n check_zero |= i == length;\n if check_zero {\n assert(is_empty(array[i]), \"invalid right padded array\");\n }\n }\n length\n}\n\n#[test]\nfn smoke_validate_array() {\n let valid_array: [Field; 0] = [];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [0];\n assert(validate_array(valid_array) == 0);\n\n let valid_array = [3];\n assert(validate_array(valid_array) == 1);\n\n let valid_array = [1, 2, 3];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0];\n assert(validate_array(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n let valid_array: [Field; 0] = [];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [0];\n assert(padded_array_length(valid_array) == 0);\n\n let valid_array = [3];\n assert(padded_array_length(valid_array) == 1);\n\n let valid_array = [1, 0, 3];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 0, 3, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [1, 2, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n\n let valid_array = [0, 0, 3, 0, 0];\n assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n let invalid_array = [0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n let invalid_array = [1, 0, 0, 1, 0];\n let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n let invalid_array = [0, 0, 0, 0, 1];\n let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n assert_eq(array_length([0]), 0);\n assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n assert_eq(array_length([123]), 1);\n assert_eq(array_length([123, 0, 0]), 1);\n assert_eq(array_length([123, 456]), 2);\n assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n // Result can be misleading (but correct) for invalid arrays.\n assert_eq(array_length([0, 0, 123]), 0);\n assert_eq(array_length([0, 123, 0]), 0);\n assert_eq(array_length([0, 123, 456]), 0);\n assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n let values = [10, 20, 30, 40];\n let min = 22;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n let values = [10, 20, 30, 40];\n let min = 100;\n let index = find_index_hint(values, |v: Field| min.lt(v));\n assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n let array0 = [1, 2, 3];\n let array1 = [4, 5];\n let concatenated = array_concat(array0, array1);\n assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n let original_array = [1, 2, 3];\n let permuted_array = [3, 1, 2];\n let indexes = [2, 0, 1];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n let original_array = [0, 1, 0];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 0];\n check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n let original_array = [0, 1, 2];\n let permuted_array = [1, 0, 0];\n let indexes = [1, 0, 2];\n check_permutation(original_array, permuted_array, indexes);\n}\n"
2769
2769
  },
2770
- "354": {
2770
+ "356": {
2771
2771
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
2772
2772
  "source": "pub struct Reader<let N: u32> {\n data: [Field; N],\n offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n pub fn new(data: [Field; N]) -> Self {\n Self { data, offset: 0 }\n }\n\n pub fn read(&mut self) -> Field {\n let result = self.data[self.offset];\n self.offset += 1;\n result\n }\n\n pub fn read_u32(&mut self) -> u32 {\n self.read() as u32\n }\n\n pub fn read_bool(&mut self) -> bool {\n self.read() as bool\n }\n\n pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n let mut result = [0; K];\n for i in 0..K {\n result[i] = self.data[self.offset + i];\n }\n self.offset += K;\n result\n }\n\n pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n let result = deserialise(self.read_array());\n result\n }\n\n pub fn read_struct_array<T, let K: u32, let C: u32>(\n &mut self,\n deserialise: fn([Field; K]) -> T,\n mut result: [T; C],\n ) -> [T; C] {\n for i in 0..C {\n result[i] = self.read_struct(deserialise);\n }\n result\n }\n\n pub fn finish(self) {\n assert(self.offset == self.data.len(), \"Reader did not read all data\");\n }\n}\n"
2773
2773
  },
@@ -2789,7 +2789,7 @@
2789
2789
  },
2790
2790
  "6": {
2791
2791
  "path": "std/collections/bounded_vec.nr",
2792
- "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec<Field, 10> {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec<Field, 3> = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n"
2792
+ "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n/// vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n storage: [T; MaxLen],\n len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n /// Creates a new, empty vector of length zero.\n ///\n /// Since this container is backed by an array internally, it still needs an initial value\n /// to give each element. To resolve this, each element is zeroed internally. This value\n /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n ///\n /// Example:\n ///\n /// ```noir\n /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n /// assert(empty_vector.len() == 0);\n /// ```\n ///\n /// Note that whenever calling `new` the maximum length of the vector should always be specified\n /// via a type signature:\n ///\n /// ```noir\n /// fn good() -> BoundedVec<Field, 10> {\n /// // Ok! MaxLen is specified with a type annotation\n /// let v1: BoundedVec<Field, 3> = BoundedVec::new();\n /// let v2 = BoundedVec::new();\n ///\n /// // Ok! MaxLen is known from the type of `good`'s return value\n /// v2\n /// }\n ///\n /// fn bad() {\n /// // Error: Type annotation needed\n /// // The compiler can't infer `MaxLen` from the following code:\n /// let mut v3 = BoundedVec::new();\n /// v3.push(5);\n /// }\n /// ```\n ///\n /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n /// constraint failure at runtime when the vec is pushed to.\n pub fn new() -> Self {\n let zeroed = crate::mem::zeroed();\n BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this\n /// will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// let last = v.get(v.len() - 1);\n /// assert(first != last);\n /// }\n /// ```\n pub fn get(self, index: u32) -> T {\n assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n self.get_unchecked(index)\n }\n\n /// Retrieves an element from the vector at the given index, starting from zero, without\n /// performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element,\n /// it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n /// // Always ensure the length is larger than the largest\n /// // index passed to get_unchecked\n /// assert(v.len() > 2);\n /// let first = v.get_unchecked(0);\n /// let second = v.get_unchecked(1);\n /// let third = v.get_unchecked(2);\n /// first + second + third\n /// }\n /// ```\n pub fn get_unchecked(self, index: u32) -> T {\n self.storage[index]\n }\n\n /// Writes an element to the vector at the given index, starting from zero.\n ///\n /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n ///\n /// Example:\n ///\n /// ```noir\n /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n /// let first = v.get(0);\n /// assert(first != 42);\n /// v.set(0, 42);\n /// let new_first = v.get(0);\n /// assert(new_first == 42);\n /// }\n /// ```\n pub fn set(&mut self, index: u32, value: T) {\n assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n self.set_unchecked(index, value)\n }\n\n /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n ///\n /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n ///\n /// Example:\n ///\n /// ```noir\n /// fn set_unchecked_example() {\n /// let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n /// vec.extend_from_array([1, 2]);\n ///\n /// // Here we're safely writing within the valid range of `vec`\n /// // `vec` now has the value [42, 2]\n /// vec.set_unchecked(0, 42);\n ///\n /// // We can then safely read this value back out of `vec`.\n /// // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n /// assert_eq(vec.get(0), 42);\n ///\n /// // We've now written past the end of `vec`.\n /// // As this index is still within the maximum potential length of `v`,\n /// // it won't cause a constraint failure.\n /// vec.set_unchecked(2, 42);\n /// println(vec);\n ///\n /// // This will write past the end of the maximum potential length of `vec`,\n /// // it will then trigger a constraint failure.\n /// vec.set_unchecked(5, 42);\n /// println(vec);\n /// }\n /// ```\n pub fn set_unchecked(&mut self, index: u32, value: T) {\n self.storage[index] = value;\n }\n\n /// Pushes an element to the end of the vector. This increases the length\n /// of the vector by one.\n ///\n /// Panics if the new length of the vector will be greater than the max length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n ///\n /// v.push(1);\n /// v.push(2);\n ///\n /// // Panics with failed assertion \"push out of bounds\"\n /// v.push(3);\n /// ```\n pub fn push(&mut self, elem: T) {\n assert(self.len < MaxLen, \"push out of bounds\");\n\n self.storage[self.len] = elem;\n self.len += 1;\n }\n\n /// Returns the current length of this vector\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n /// assert(v.len() == 0);\n ///\n /// v.push(100);\n /// assert(v.len() == 1);\n ///\n /// v.push(200);\n /// v.push(300);\n /// v.push(400);\n /// assert(v.len() == 4);\n ///\n /// let _ = v.pop();\n /// let _ = v.pop();\n /// assert(v.len() == 2);\n /// ```\n pub fn len(self) -> u32 {\n self.len\n }\n\n /// Returns the maximum length of this vector. This is always\n /// equal to the `MaxLen` parameter this vector was initialized with.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.max_len() == 5);\n /// v.push(10);\n /// assert(v.max_len() == 5);\n /// ```\n pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n MaxLen\n }\n\n /// Returns the internal array within this vector.\n ///\n /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n /// the storage held internally by this vector.\n ///\n /// Note that uninitialized elements may be zeroed out!\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n ///\n /// assert(v.storage() == [0, 0, 0, 0, 0]);\n ///\n /// v.push(57);\n /// assert(v.storage() == [57, 0, 0, 0, 0]);\n /// ```\n pub fn storage(self) -> [T; MaxLen] {\n self.storage\n }\n\n /// Pushes each element from the given array to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_array([2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n let new_len = self.len + array.len();\n assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n for i in 0..array.len() {\n self.storage[self.len + i] = array[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the given slice to this vector.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n /// vec.extend_from_slice(&[2, 4]);\n ///\n /// assert(vec.len == 2);\n /// assert(vec.get(0) == 2);\n /// assert(vec.get(1) == 4);\n /// ```\n pub fn extend_from_slice(&mut self, slice: [T]) {\n let new_len = self.len + slice.len();\n assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n for i in 0..slice.len() {\n self.storage[self.len + i] = slice[i];\n }\n self.len = new_len;\n }\n\n /// Pushes each element from the other vector to this vector. The length of\n /// the other vector is left unchanged.\n ///\n /// Panics if pushing each element would cause the length of this vector\n /// to exceed the maximum length.\n ///\n /// ```noir\n /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n ///\n /// v2.extend_from_array([1, 2, 3]);\n /// v1.extend_from_bounded_vec(v2);\n ///\n /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n /// ```\n pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n let append_len = vec.len();\n let new_len = self.len + append_len;\n assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n if is_unconstrained() {\n for i in 0..append_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n } else {\n let mut exceeded_len = false;\n for i in 0..Len {\n exceeded_len |= i == append_len;\n if !exceeded_len {\n self.storage[self.len + i] = vec.get_unchecked(i);\n }\n }\n }\n self.len = new_len;\n }\n\n /// Creates a new vector, populating it with values derived from an array input.\n /// The maximum length of the vector is determined based on the type signature.\n ///\n /// Example:\n ///\n /// ```noir\n /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n /// ```\n pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n static_assert(Len <= MaxLen, \"from array out of bounds\");\n let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n vec.extend_from_array(array);\n vec\n }\n\n /// Pops the element at the end of the vector. This will decrease the length\n /// of the vector by one.\n ///\n /// Panics if the vector is empty.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n /// v.push(1);\n /// v.push(2);\n ///\n /// let two = v.pop();\n /// let one = v.pop();\n ///\n /// assert(two == 2);\n /// assert(one == 1);\n ///\n /// // error: cannot pop from an empty vector\n /// let _ = v.pop();\n /// ```\n pub fn pop(&mut self) -> T {\n assert(self.len > 0);\n self.len -= 1;\n\n let elem = self.storage[self.len];\n self.storage[self.len] = crate::mem::zeroed();\n elem\n }\n\n /// Returns true if the given predicate returns true for any element\n /// in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n /// v.extend_from_array([2, 4, 6]);\n ///\n /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n /// assert(all_even);\n /// ```\n pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n let mut ret = false;\n if is_unconstrained() {\n for i in 0..self.len {\n ret |= predicate(self.storage[i]);\n }\n } else {\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 }\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.map(|value| value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Creates a new vector of equal size by calling a closure on each element\n /// in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let result = vec.mapi(|i, value| i + value * 2);\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn mapi<U, Env>(self, f: fn[Env](u32, T) -> U) -> BoundedVec<U, MaxLen> {\n let mut ret = BoundedVec::new();\n ret.len = self.len();\n\n if is_unconstrained() {\n for i in 0..self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n ret.storage[i] = f(i, self.get_unchecked(i));\n }\n }\n }\n\n ret\n }\n\n /// Calls a closure on each element in this vector.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_each(|value| result.push(value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_each<Env>(self, f: fn[Env](T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Calls a closure on each element in this vector, along with its index.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n /// let mut result = BoundedVec::<u32, 4>::new();\n /// vec.for_eachi(|i, value| result.push(i + value * 2));\n ///\n /// let expected = BoundedVec::from_array([2, 5, 8, 11]);\n /// assert_eq(result, expected);\n /// ```\n pub fn for_eachi<Env>(self, f: fn[Env](u32, T) -> ()) {\n if is_unconstrained() {\n for i in 0..self.len() {\n f(i, self.get_unchecked(i));\n }\n } else {\n for i in 0..MaxLen {\n if i < self.len() {\n f(i, self.get_unchecked(i));\n }\n }\n }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function will zero out any elements at or past index `len` of `array`.\n /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n /// ```\n pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n let zeroed = crate::mem::zeroed();\n\n if is_unconstrained() {\n for i in len..MaxLen {\n array[i] = zeroed;\n }\n } else {\n for i in 0..MaxLen {\n if i >= len {\n array[i] = zeroed;\n }\n }\n }\n\n BoundedVec { storage: array, len }\n }\n\n /// Creates a new BoundedVec from the given array and length.\n /// The given length must be less than or equal to the length of the array.\n ///\n /// This function is unsafe because it expects all elements past the `len` index\n /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n /// for a safe version of this function which does zero out any indices past the\n /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n /// to give incorrect results since it will check even elements past `len`.\n ///\n /// Example:\n ///\n /// ```noir\n /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n /// assert_eq(vec.len(), 3);\n ///\n /// // invalid use!\n /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n ///\n /// // both vecs have length 3 so we'd expect them to be equal, but this\n /// // fails because elements past the length are still checked in eq\n /// assert_eq(vec1, vec2); // fails\n /// ```\n pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n assert(len <= MaxLen);\n BoundedVec { storage: array, len }\n }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n T: Eq,\n{\n fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n // TODO: https://github.com/noir-lang/noir/issues/4837\n //\n // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n if self.len == other.len {\n self.storage == other.storage\n } else {\n false\n }\n }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n BoundedVec::from_array(array)\n }\n}\n\nmod bounded_vec_tests {\n\n mod get {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n fn panics_when_reading_elements_past_end_of_vec() {\n let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n crate::println(vec.get(0));\n }\n }\n\n mod set {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn set_updates_values_properly() {\n let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n vec.set(0, 42);\n assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n vec.set(1, 43);\n assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n vec.set(2, 44);\n assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n vec.set(1, 10);\n assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n vec.set(0, 0);\n assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n }\n\n #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n fn panics_when_writing_elements_past_end_of_vec() {\n let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n vec.set(0, 42);\n\n // Need to use println to avoid DIE removing the write operation.\n crate::println(vec.get(0));\n }\n }\n\n mod map {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-map-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| value * 2);\n // docs:end:bounded-vec-map-example\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.map(|value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.map(|value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod mapi {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn applies_function_correctly() {\n // docs:start:bounded-vec-mapi-example\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| i + value * 2);\n // docs:end:bounded-vec-mapi-example\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = vec.mapi(|i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = vec.mapi(|_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_each {\n use crate::collections::bounded_vec::BoundedVec;\n\n // map in terms of for_each\n fn for_each_map<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_each(|x| output_ref.push(f(x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-each-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_each(|value| { *acc_ref += value; });\n // docs:end:bounded-vec-for-each-example\n assert_eq(acc, 6);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| value * 2);\n let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_each_map(vec, |value| (value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_each_map(vec, |value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod for_eachi {\n use crate::collections::bounded_vec::BoundedVec;\n\n // mapi in terms of for_eachi\n fn for_eachi_mapi<T, U, Env, let MaxLen: u32>(\n input: BoundedVec<T, MaxLen>,\n f: fn[Env](u32, T) -> U,\n ) -> BoundedVec<U, MaxLen> {\n let mut output = BoundedVec::<U, MaxLen>::new();\n let output_ref = &mut output;\n input.for_eachi(|i, x| output_ref.push(f(i, x)));\n output\n }\n\n #[test]\n fn smoke_test() {\n let mut acc = 0;\n let acc_ref = &mut acc;\n // docs:start:bounded-vec-for-eachi-example\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([1, 2, 3]);\n vec.for_eachi(|i, value| { *acc_ref += i * value; });\n // docs:end:bounded-vec-for-eachi-example\n\n // 0 * 1 + 1 * 2 + 2 * 3\n assert_eq(acc, 8);\n }\n\n #[test]\n fn applies_function_correctly() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| i + value * 2);\n let expected = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn applies_function_that_changes_return_type() {\n let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n let result = for_eachi_mapi(vec, |i, value| (i + value * 2) as Field);\n let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 5, 8, 11]);\n\n assert_eq(result, expected);\n }\n\n #[test]\n fn does_not_apply_function_past_len() {\n let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n let result = for_eachi_mapi(vec, |_, value| if value == 0 { 5 } else { value });\n let expected = BoundedVec::from_array([5, 1]);\n\n assert_eq(result, expected);\n assert_eq(result.get_unchecked(2), 0);\n }\n }\n\n mod from_array {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty() {\n let empty_array: [Field; 0] = [];\n let bounded_vec = BoundedVec::from_array([]);\n\n assert_eq(bounded_vec.max_len(), 0);\n assert_eq(bounded_vec.len(), 0);\n assert_eq(bounded_vec.storage(), empty_array);\n }\n\n #[test]\n fn equal_len() {\n let array = [1, 2, 3];\n let bounded_vec = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 3);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.storage(), array);\n }\n\n #[test]\n fn max_len_greater_then_array_len() {\n let array = [1, 2, 3];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 3);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n assert_eq(bounded_vec.get(2), 3);\n }\n\n #[test(should_fail_with = \"from array out of bounds\")]\n fn max_len_lower_then_array_len() {\n let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n }\n }\n\n mod trait_from {\n use crate::collections::bounded_vec::BoundedVec;\n use crate::convert::From;\n\n #[test]\n fn simple() {\n let array = [1, 2];\n let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n assert_eq(bounded_vec.max_len(), 10);\n assert_eq(bounded_vec.len(), 2);\n assert_eq(bounded_vec.get(0), 1);\n assert_eq(bounded_vec.get(1), 2);\n }\n }\n\n mod trait_eq {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn empty_equality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n assert_eq(bounded_vec1, bounded_vec2);\n }\n\n #[test]\n fn inequality() {\n let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n bounded_vec1.push(1);\n bounded_vec2.push(2);\n\n assert(bounded_vec1 != bounded_vec2);\n }\n }\n\n mod from_parts {\n use crate::collections::bounded_vec::BoundedVec;\n\n #[test]\n fn from_parts() {\n // docs:start:from-parts\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // Any elements past the given length are zeroed out, so these\n // two BoundedVecs will be completely equal\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n assert_eq(vec1, vec2);\n // docs:end:from-parts\n }\n\n #[test]\n fn from_parts_unchecked() {\n // docs:start:from-parts-unchecked\n let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n assert_eq(vec.len(), 3);\n\n // invalid use!\n let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n // both vecs have length 3 so we'd expect them to be equal, but this\n // fails because elements past the length are still checked in eq\n assert(vec1 != vec2);\n // docs:end:from-parts-unchecked\n }\n }\n}\n"
2793
2793
  },
2794
2794
  "64": {
2795
2795
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
@@ -2817,21 +2817,21 @@
2817
2817
  },
2818
2818
  "77": {
2819
2819
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr",
2820
- "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal NOTE_PRIVATE_LOG_RESERVED_FIELDS: u32 = 2;\n\n/// The maximum length of the packed representation of a note's contents. This is limited by private log size, encryption\n/// overhead and extra fields in the log (e.g. the combined log and note type ID).\npub global MAX_NOTE_PACKED_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - NOTE_PRIVATE_LOG_RESERVED_FIELDS;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of note discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note_content, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note_content.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note_content */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the note discovery process, in which private and public logs are downloaded and inspected to find private\n/// notes, partial notes, and their completion. This is the mechanism via which PXE learns of new notes.\n///\n/// Receives the address of the contract on which discovery is performed (i.e. the contract that emitted the notes)\n/// along with its `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_notes<Env>(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n debug_log(\"Performing note discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n"
2820
+ "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n /// The result of NoteHash::compute_note_hash\n pub note_hash: Field,\n /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n/// if note_type_id == MyNoteType::get_id() {\n/// assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n/// let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n/// let note_hash = note.compute_note_hash(storage_slot);\n/// let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n/// RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n/// storage_slot\n/// );\n///\n/// let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n/// Option::some(\n/// aztec::discovery::NoteHashAndNullifier {\n/// note_hash, inner_nullifier\n/// }\n/// )\n/// } else if note_type_id == MyOtherNoteType::get_id() {\n/// ... // Similar to above but calling MyOtherNoteType::unpack_content\n/// } else {\n/// Option::none() // Unknown note type ID\n/// };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n debug_log(\"Performing message discovery\");\n\n private_logs::fetch_and_process_private_tagged_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n\n partial_notes::fetch_and_process_public_partial_note_completion_logs(\n contract_address,\n compute_note_hash_and_nullifier,\n );\n}\n"
2821
2821
  },
2822
2822
  "78": {
2823
2823
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr",
2824
- "source": "use crate::{discovery::{ComputeNoteHashAndNullifier, MAX_NOTE_PACKED_LEN}, utils::array};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery<Env>(\n unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note_content: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting note discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note_content,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n"
2824
+ "source": "use crate::{\n discovery::{ComputeNoteHashAndNullifier, private_notes::MAX_NOTE_PACKED_LEN},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::MAX_NOTE_HASHES_PER_TX,\n debug_log::debug_log_format,\n hash::{compute_note_hash_nonce, compute_siloed_note_hash, compute_unique_note_hash},\n traits::ToField,\n};\n\n/// A struct with the discovered information of a complete note, required for delivery to PXE. Note that this is *not*\n/// the complete note information, since it does not include content, storage slot, etc.\npub struct DiscoveredNoteInfo {\n pub nonce: Field,\n pub note_hash: Field,\n pub inner_nullifier: Field,\n}\n\n/// Searches for note nonces that will result in a note that was emitted in a transaction. While rare, it is possible\n/// for multiple notes to have the exact same packed content and storage slot but different nonces, resulting in\n/// different unique note hashes. Because of this this function returns a *vector* of discovered notes, though in most\n/// cases it will contain a single element.\n///\n/// Due to how nonces are computed, this function requires knowledge of the transaction in which the note was created,\n/// more specifically the list of all unique note hashes in it plus the value of its first nullifier.\npub unconstrained fn attempt_note_nonce_discovery<Env>(\n unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) -> BoundedVec<DiscoveredNoteInfo, MAX_NOTE_HASHES_PER_TX> {\n let discovered_notes = &mut BoundedVec::new();\n\n debug_log_format(\n \"Attempting nonce discovery on {0} potential notes on contract {1} for storage slot {2}\",\n [unique_note_hashes_in_tx.len() as Field, contract_address.to_field(), storage_slot],\n );\n\n // We need to find nonces (typically just one) that result in a note hash that, once siloed into a unique note hash,\n // is one of the note hashes created by the transaction.\n array::for_each_in_bounded_vec(\n unique_note_hashes_in_tx,\n |expected_unique_note_hash, i| {\n // Nonces are computed by hashing the first nullifier in the transaction with the index of the note in the\n // new note hashes array. We therefore know for each note in every transaction what its nonce is.\n let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n // Given nonce, note content and metadata, we can compute the note hash and silo it to check if it matches\n // the note hash at the array index we're currently processing.\n // TODO(#11157): handle failed note_hash_and_nullifier computation\n let hashes = compute_note_hash_and_nullifier(\n packed_note,\n storage_slot,\n note_type_id,\n contract_address,\n candidate_nonce,\n )\n .expect(f\"Failed to compute a note hash for note type {note_type_id}\");\n\n let siloed_note_hash = compute_siloed_note_hash(contract_address, hashes.note_hash);\n let unique_note_hash = compute_unique_note_hash(candidate_nonce, siloed_note_hash);\n\n if unique_note_hash == expected_unique_note_hash {\n // Note that while we did check that the note hash is the preimage of the expected unique note hash, we\n // perform no validations on the nullifier - we fundamentally cannot, since only the application knows\n // how to compute nullifiers. We simply trust it to have provided the correct one: if it hasn't, then\n // PXE may fail to realize that a given note has been nullified already, and calls to the application\n // could result in invalid transactions (with duplicate nullifiers). This is not a concern because an\n // application already has more direct means of making a call to it fail the transaction.\n discovered_notes.push(\n DiscoveredNoteInfo {\n nonce: candidate_nonce,\n note_hash: hashes.note_hash,\n inner_nullifier: hashes.inner_nullifier,\n },\n );\n\n // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n // notes containing random values in order to hide their contents.\n }\n },\n );\n\n debug_log_format(\n \"Discovered a total of {0} notes\",\n [discovered_notes.len() as Field],\n );\n\n *discovered_notes\n}\n"
2825
2825
  },
2826
2826
  "79": {
2827
2827
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/partial_notes.nr",
2828
- "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n private_logs::MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN,\n },\n oracle::note_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n traits::{Deserialize, Serialize, ToField},\n};\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\n// TODO(#11630): come up with some sort of slot allocation scheme.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = 77;\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n pub(crate) recipient: AztecAddress,\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs<Env>(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = &mut 0;\n whyle(\n || *i < pending_partial_notes.len(),\n || {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(*i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n *i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing note discovery in the future until we either find it or the entry\n // is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note_content = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note_content,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note_content,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(*i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n },\n );\n}\n\n/// Custom version of a while loop, calls `body` repeatedly until `condition` returns false. To be removed once Noir\n/// supports looping in unconstrained code.\nfn whyle<Env, Env2>(condition: fn[Env]() -> bool, body: fn[Env2]() -> ()) {\n if condition() {\n body();\n whyle(condition, body);\n }\n}\n"
2828
+ "source": "use crate::{\n capsules::CapsuleArray,\n discovery::{\n ComputeNoteHashAndNullifier,\n MAX_LOG_CONTENT_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n },\n oracle::message_discovery::{deliver_note, get_log_by_tag},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::PUBLIC_LOG_DATA_SIZE_IN_FIELDS,\n debug_log::debug_log_format,\n traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN: u32 = 2;\n\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (e.g.\n/// the storage slot, note completion log tag, etc.).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_LOG_CONTENT_LEN - PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN;\n\n/// The slot in the PXE capsules where we store a `CapsuleArray` of `DeliveredPendingPartialNote`.\n// TODO(#11630): come up with some sort of slot allocation scheme.\npub global DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT: Field = 77;\n\n/// Public logs contain an extra field at the beginning with the address of the contract that emitted them, and partial\n/// notes emit their completion tag in the log, resulting in the first two fields in the public log not being part of\n/// the packed public content.\n// TODO(#10273): improve how contract log siloing is handled\npub global NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG: u32 = 2;\n\n/// The maximum length of the packed representation of public fields in a partial note. This is limited by public log\n/// size and extra fields in the log (e.g. the tag).\npub global MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH: u32 =\n PUBLIC_LOG_DATA_SIZE_IN_FIELDS - NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG;\n\n/// A partial note that was delivered but is still pending completion. Contains the information necessary to find the\n/// log that will complete it and lead to a note being discovered and delivered.\n#[derive(Serialize, Deserialize)]\npub(crate) struct DeliveredPendingPartialNote {\n pub(crate) note_completion_log_tag: Field,\n pub(crate) storage_slot: Field,\n pub(crate) note_type_id: Field,\n pub(crate) packed_private_note_content: BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>,\n pub(crate) recipient: AztecAddress,\n}\n\npub unconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n recipient: AztecAddress,\n log_metadata: u64,\n log_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN>,\n) {\n let (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content) =\n decode_partial_note_private_log(log_metadata, log_content);\n\n // We store the information of the partial note we found in a persistent capsule in PXE, so that we can later search\n // for the public log that will complete it.\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag,\n storage_slot,\n note_type_id,\n packed_private_note_content,\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n\n/// Searches for public logs that would result in the completion of pending partial notes, ultimately resulting in the\n/// notes being delivered to PXE if completed.\npub unconstrained fn fetch_and_process_public_partial_note_completion_logs<Env>(\n contract_address: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n let pending_partial_notes = CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n );\n\n debug_log_format(\n \"{} pending partial notes\",\n [pending_partial_notes.len() as Field],\n );\n\n let mut i = 0;\n while i < pending_partial_notes.len() {\n let pending_partial_note: DeliveredPendingPartialNote = pending_partial_notes.get(i);\n\n let maybe_log = get_log_by_tag(pending_partial_note.note_completion_log_tag);\n if maybe_log.is_none() {\n debug_log_format(\n \"Found no completion logs for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n i += 1 as u32;\n // Note that we're not removing the pending partial note from the PXE DB, so we will continue searching\n // for this tagged log when performing message discovery in the future until we either find it or the\n // entry is somehow removed from the PXE DB.\n } else {\n debug_log_format(\n \"Completion log found for partial note with tag {}\",\n [pending_partial_note.note_completion_log_tag],\n );\n let log = maybe_log.unwrap();\n\n // Public logs have an extra field at the beginning with the contract address, which we use to verify\n // that we're getting the logs from the expected contract.\n // TODO(#10273): improve how contract log siloing is handled\n assert_eq(\n log.log_content.get(0),\n contract_address.to_field(),\n \"Got a public log emitted by a different contract\",\n );\n\n // Public fields are assumed to all be placed at the end of the packed representation, so we combine the\n // private and public packed fields (i.e. the contents of the log sans the extra fields) to get the\n // complete packed content.\n let packed_public_note_content: BoundedVec<_, MAX_PUBLIC_PARTIAL_NOTE_PACKED_CONTENT_LENGTH> =\n array::subbvec(log.log_content, NON_PACKED_CONTENT_FIELDS_IN_PUBLIC_LOG);\n let complete_packed_note = array::append(\n pending_partial_note.packed_private_note_content,\n packed_public_note_content,\n );\n\n let discovered_notes = attempt_note_nonce_discovery(\n log.unique_note_hashes_in_tx,\n log.first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n pending_partial_note.storage_slot,\n pending_partial_note.note_type_id,\n complete_packed_note,\n );\n\n debug_log_format(\n \"Discovered {0} notes for partial note with tag {1}\",\n [discovered_notes.len() as Field, pending_partial_note.note_completion_log_tag],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): decide how to handle notes that fail delivery. This could be due to e.g. a\n // temporary node connectivity issue - is simply throwing good enough here?\n assert(\n deliver_note(\n contract_address,\n pending_partial_note.storage_slot,\n discovered_note.nonce,\n complete_packed_note,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n log.tx_hash,\n pending_partial_note.recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n\n // Because there is only a single log for a given tag, once we've processed the tagged log then we\n // simply delete the pending work entry, regardless of whether it was actually completed or not.\n // TODO(#11627): only remove the pending entry if we actually process a log that results in the note\n // being completed.\n pending_partial_notes.remove(i);\n\n // We don't increment `i` here, because CapsuleArray is contiguous and its `remove(...)` function\n // shifts the elements to the left if the removed element is not the last element.\n }\n }\n}\n\nfn decode_partial_note_private_log(\n log_metadata: u64,\n log_content: BoundedVec<Field, MAX_LOG_CONTENT_LEN>,\n) -> (Field, Field, Field, BoundedVec<Field, MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN>) {\n let note_type_id = log_metadata as Field; // TODO: make note type id not be a full field\n\n assert(\n log_content.len() > PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN,\n f\"Invalid private note log: all partial note private logs must have at least {PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN} fields\",\n );\n\n // If PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN is changed, causing the assertion below to fail, then the\n // destructuring of the partial note private log encoding below must be updated as well.\n std::static_assert(\n PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN == 2,\n \"unexpected value for PARTIAL_NOTE_PRIVATE_LOG_CONTENT_NON_NOTE_FIELDS_LEN\",\n );\n\n // We currently have two fields that are not the partial note's packed representation, which are the storage slot\n // and the note completion log tag.\n let storage_slot = log_content.get(0);\n let note_completion_log_tag = log_content.get(1);\n\n let packed_private_note_content = array::subbvec(log_content, 2);\n\n (note_type_id, storage_slot, note_completion_log_tag, packed_private_note_content)\n}\n"
2829
2829
  },
2830
2830
  "80": {
2831
2831
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr",
2832
- "source": "use std::static_assert;\n\nuse crate::{\n capsules::CapsuleArray,\n oracle::note_discovery::{deliver_note, sync_notes},\n utils::array,\n};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n ComputeNoteHashAndNullifier,\n MAX_NOTE_PACKED_LEN,\n nonce_discovery::{attempt_note_nonce_discovery, DiscoveredNoteInfo},\n NOTE_PRIVATE_LOG_RESERVED_FIELDS,\n partial_notes::{\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT, DeliveredPendingPartialNote,\n },\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\npub global PARTIAL_NOTE_COMPLETION_LOG_TAG_LEN: u32 = 1;\n/// Partial notes have a maximum packed length of their private fields bound by extra content in their private log (i.e.\n/// the note completion log tag).\npub global MAX_PARTIAL_NOTE_PRIVATE_PACKED_LEN: u32 =\n MAX_NOTE_PACKED_LEN - PARTIAL_NOTE_COMPLETION_LOG_TAG_LEN;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes. Private\n/// notes result in nonce discovery being performed prior to delivery, which requires knowledge of the transaction hash in\n/// which the notes would've been created (typically the same transaction in which the log was emitted), along with the\n/// list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier` function.\npub unconstrained fn do_process_log<Env>(\n contract_address: AztecAddress,\n log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n let log_plaintext = decrypt_log(log, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n // improved upon in the future to also handle events, etc.\n\n let (storage_slot, note_type_id, log_type_id, log_payload) =\n destructure_log_plaintext(log_plaintext);\n\n if log_type_id == 0 {\n debug_log(\"Processing private note log\");\n\n attempt_note_discovery(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n storage_slot,\n note_type_id,\n log_payload,\n );\n } else if log_type_id == 1 {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(\n contract_address,\n storage_slot,\n note_type_id,\n log_payload,\n recipient,\n );\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id],\n );\n }\n}\n\nunconstrained fn destructure_log_plaintext(\n log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (Field, Field, Field, BoundedVec<Field, MAX_NOTE_PACKED_LEN>) {\n assert(log_plaintext.len() >= NOTE_PRIVATE_LOG_RESERVED_FIELDS);\n\n // If NOTE_PRIVATE_LOG_RESERVED_FIELDS is changed, causing the assertion below to fail, then the declarations for\n // `storage_slot` and `note_type_id` must be updated as well.\n static_assert(\n NOTE_PRIVATE_LOG_RESERVED_FIELDS == 2,\n \"unexpected value for NOTE_PRIVATE_LOG_RESERVED_FIELDS\",\n );\n let storage_slot = log_plaintext.get(0);\n\n // We currently identify log types by packing the log type ID and note type ID into a single field, called the\n // combined type ID. We can do this because the note type ID is only 7 bits long, and so use an 8th bit to\n // distinguish private note logs and partial note logs.\n // This abuses the fact that the encoding of both of these logs is extremely similar, and will need improving and\n // more formalization once we introduce other dissimilar log types, such as events. Ideally we'd be able to\n // leverage enums and tagged unions to achieve this goal.\n let combined_type_id = log_plaintext.get(1);\n let note_type_id = ((combined_type_id as u64) % 128) as Field;\n let log_type_id = ((combined_type_id as u64) / 128) as Field;\n\n let log_payload = array::subbvec(log_plaintext, NOTE_PRIVATE_LOG_RESERVED_FIELDS);\n\n (storage_slot, note_type_id, log_type_id, log_payload)\n}\n\n/// Attempts discovery of a note given information about its contents and the transaction in which it is\n/// suspected the note was created.\npub unconstrained fn attempt_note_discovery<Env>(\n contract_address: AztecAddress,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n storage_slot: Field,\n note_type_id: Field,\n packed_note_content: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n) {\n let discovered_notes = attempt_note_nonce_discovery(\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n compute_note_hash_and_nullifier,\n contract_address,\n storage_slot,\n note_type_id,\n packed_note_content,\n );\n\n debug_log_format(\n \"Discovered {0} notes from a private log\",\n [discovered_notes.len() as Field],\n );\n\n array::for_each_in_bounded_vec(\n discovered_notes,\n |discovered_note: DiscoveredNoteInfo, _| {\n // TODO:(#10728): handle notes that fail delivery. This could be due to e.g. a temporary node connectivity\n // issue, and we should perhaps not have marked the tag index as taken.\n assert(\n deliver_note(\n contract_address,\n storage_slot,\n discovered_note.nonce,\n packed_note_content,\n discovered_note.note_hash,\n discovered_note.inner_nullifier,\n tx_hash,\n recipient,\n ),\n \"Failed to deliver note\",\n );\n },\n );\n}\n\nunconstrained fn process_partial_note_private_log(\n contract_address: AztecAddress,\n storage_slot: Field,\n note_type_id: Field,\n log_payload: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n recipient: AztecAddress,\n) {\n // We store the information of the partial note we found so that we can later search for the public log that will\n // complete it. The tag is the first value in the payload, with the packed note content taking up the rest of it.\n static_assert(\n PARTIAL_NOTE_COMPLETION_LOG_TAG_LEN == 1,\n \"unexpected value for PARTIAL_NOTE_COMPLETION_LOG_TAG_LEN\",\n );\n\n let pending = DeliveredPendingPartialNote {\n note_completion_log_tag: log_payload.get(0),\n storage_slot,\n note_type_id,\n packed_private_note_content: array::subbvec(log_payload, 1),\n recipient,\n };\n\n CapsuleArray::at(\n contract_address,\n DELIVERED_PENDING_PARTIAL_NOTE_ARRAY_LENGTH_CAPSULES_SLOT,\n )\n .push(pending);\n}\n"
2832
+ "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n address::AztecAddress,\n constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n _contract_address: AztecAddress,\n _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n // decrypted log, letting us continue the work outside of PXE.\n sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log<Env>(\n contract_address: AztecAddress,\n log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n tx_hash: Field,\n unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n first_nullifier_in_tx: Field,\n recipient: AztecAddress,\n compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n let log_plaintext = decrypt_log(log, recipient);\n\n // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n // improved upon in the future to also handle events, etc.\n\n let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n if log_type_id == 0 {\n debug_log(\"Processing private note log\");\n\n process_private_note_log(\n contract_address,\n tx_hash,\n unique_note_hashes_in_tx,\n first_nullifier_in_tx,\n recipient,\n compute_note_hash_and_nullifier,\n log_metadata,\n log_content,\n );\n } else if log_type_id == 1 {\n debug_log(\"Processing partial note private log\");\n\n process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n } else {\n // TODO(#11569): handle events\n debug_log_format(\n \"Unknown log type id {0} (probably belonging to an event log)\",\n [log_type_id as Field],\n );\n }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n/// - an initial field called the 'expanded metadata'\n/// - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n/// - the upper 57 bits are the log type id\n/// - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [ log_type_id | log_metadata ]\n/// <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (u64, u64, BoundedVec<Field, MAX_LOG_CONTENT_LEN>) {\n assert(\n log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n );\n\n // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n // the log encoding below must be updated as well.\n std::static_assert(\n PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n );\n\n // See the documentation of this function for a description of the log layout\n let expanded_log_metadata = log_plaintext.get(0);\n\n let log_type_id = ((expanded_log_metadata as u64) / 128);\n let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n (log_type_id, log_metadata, log_content)\n}\n"
2833
2833
  },
2834
- "94": {
2834
+ "95": {
2835
2835
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
2836
2836
  "source": "use dep::protocol_types::{\n address::{AztecAddress, EthAddress},\n constants::{\n GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n GENERATOR_INDEX__SECRET_HASH,\n },\n hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n point::Point,\n traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n sender: EthAddress,\n chain_id: Field,\n recipient: AztecAddress,\n version: Field,\n content: Field,\n secret_hash: Field,\n leaf_index: Field,\n) -> Field {\n let mut hash_bytes = [0 as u8; 224];\n let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n let version_bytes: [u8; 32] = version.to_be_bytes();\n let content_bytes: [u8; 32] = content.to_be_bytes();\n let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n for i in 0..32 {\n hash_bytes[i] = sender_bytes[i];\n hash_bytes[i + 32] = chain_id_bytes[i];\n hash_bytes[i + 64] = recipient_bytes[i];\n hash_bytes[i + 96] = version_bytes[i];\n hash_bytes[i + 128] = content_bytes[i];\n hash_bytes[i + 160] = secret_hash_bytes[i];\n hash_bytes[i + 192] = leaf_index_bytes[i];\n }\n\n sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n fn hash(self) -> Field {\n hash_args(self.fields)\n }\n}\n\nimpl ArgsHasher {\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<let N: u32>(&mut self, fields: [Field; N]) {\n for i in 0..N {\n self.fields = self.fields.push_back(fields[i]);\n }\n }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n if args.len() == 0 {\n 0\n } else {\n poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n let mut input = ArgsHasher::new();\n for i in 0..100 {\n input.add(i as Field);\n }\n let hash = input.hash();\n dep::std::println(hash);\n assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
2837
2837
  }