@aztec/protocol-contracts 0.85.0 → 0.86.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 +582 -582
  2. package/artifacts/ContractClassRegisterer.json +183 -179
  3. package/artifacts/ContractInstanceDeployer.json +125 -125
  4. package/artifacts/FeeJuice.json +123 -123
  5. package/artifacts/MultiCallEntrypoint.json +27 -27
  6. package/artifacts/Router.json +94 -94
  7. package/dest/protocol_contract_data.js +7 -7
  8. package/package.json +4 -6
  9. package/src/protocol_contract_data.ts +7 -7
package/artifacts/AuthRegistry.json CHANGED
@@ -4,446 +4,136 @@
4
4
  "name": "AuthRegistry",
5
5
  "functions": [
6
6
  {
7
- "name": "is_consumable",
8
- "is_unconstrained": true,
7
+ "name": "set_authorized_private",
8
+ "is_unconstrained": false,
9
9
  "custom_attributes": [
10
- "public",
11
- "view"
10
+ "private"
12
11
  ],
13
12
  "abi": {
14
13
  "parameters": [
15
14
  {
16
- "name": "on_behalf_of",
15
+ "name": "inputs",
17
16
  "type": {
18
17
  "kind": "struct",
19
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
18
+ "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs",
20
19
  "fields": [
21
20
  {
22
- "name": "inner",
21
+ "name": "call_context",
23
22
  "type": {
24
- "kind": "field"
23
+ "kind": "struct",
24
+ "path": "authwit::aztec::protocol_types::abis::call_context::CallContext",
25
+ "fields": [
26
+ {
27
+ "name": "msg_sender",
28
+ "type": {
29
+ "kind": "struct",
30
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
31
+ "fields": [
32
+ {
33
+ "name": "inner",
34
+ "type": {
35
+ "kind": "field"
36
+ }
37
+ }
38
+ ]
39
+ }
40
+ },
41
+ {
42
+ "name": "contract_address",
43
+ "type": {
44
+ "kind": "struct",
45
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
46
+ "fields": [
47
+ {
48
+ "name": "inner",
49
+ "type": {
50
+ "kind": "field"
51
+ }
52
+ }
53
+ ]
54
+ }
55
+ },
56
+ {
57
+ "name": "function_selector",
58
+ "type": {
59
+ "kind": "struct",
60
+ "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
61
+ "fields": [
62
+ {
63
+ "name": "inner",
64
+ "type": {
65
+ "kind": "integer",
66
+ "sign": "unsigned",
67
+ "width": 32
68
+ }
69
+ }
70
+ ]
71
+ }
72
+ },
73
+ {
74
+ "name": "is_static_call",
75
+ "type": {
76
+ "kind": "boolean"
77
+ }
78
+ }
79
+ ]
25
80
  }
26
- }
27
- ]
28
- },
29
- "visibility": "private"
30
- },
31
- {
32
- "name": "message_hash",
33
- "type": {
34
- "kind": "field"
35
- },
36
- "visibility": "private"
37
- }
38
- ],
39
- "return_type": {
40
- "abi_type": {
41
- "kind": "boolean"
42
- },
43
- "visibility": "public"
44
- },
45
- "error_types": {
46
- "206160798890201757": {
47
- "error_kind": "string",
48
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
49
- },
50
- "5019202896831570965": {
51
- "error_kind": "string",
52
- "string": "attempt to add with overflow"
53
- },
54
- "5444967152290923376": {
55
- "error_kind": "string",
56
- "string": "Function is_consumable can only be called statically"
57
- },
58
- "14225679739041873922": {
59
- "error_kind": "string",
60
- "string": "Index out of bounds"
61
- },
62
- "17843811134343075018": {
63
- "error_kind": "string",
64
- "string": "Stack too deep"
65
- }
66
- }
67
- },
68
- "bytecode": "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",
69
- "debug_symbols": "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",
70
- "brillig_names": [
71
- "is_consumable"
72
- ]
73
- },
74
- {
75
- "name": "public_dispatch",
76
- "is_unconstrained": true,
77
- "custom_attributes": [
78
- "public"
79
- ],
80
- "abi": {
81
- "parameters": [
82
- {
83
- "name": "selector",
84
- "type": {
85
- "kind": "field"
86
- },
87
- "visibility": "private"
88
- }
89
- ],
90
- "return_type": null,
91
- "error_types": {
92
- "206160798890201757": {
93
- "error_kind": "string",
94
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
95
- },
96
- "715723737710351018": {
97
- "error_kind": "string",
98
- "string": "rejecting all"
99
- },
100
- "2830029349304997821": {
101
- "error_kind": "fmtstring",
102
- "length": 27,
103
- "item_types": [
104
- {
105
- "kind": "field"
106
- }
107
- ]
108
- },
109
- "5019202896831570965": {
110
- "error_kind": "string",
111
- "string": "attempt to add with overflow"
112
- },
113
- "5444967152290923376": {
114
- "error_kind": "string",
115
- "string": "Function is_consumable can only be called statically"
116
- },
117
- "6304245522015439386": {
118
- "error_kind": "string",
119
- "string": "Function _set_authorized can only be called internally"
120
- },
121
- "9474245853673257536": {
122
- "error_kind": "string",
123
- "string": "Function is_reject_all can only be called statically"
124
- },
125
- "12737498021964987455": {
126
- "error_kind": "string",
127
- "string": "unauthorized"
128
- },
129
- "14225679739041873922": {
130
- "error_kind": "string",
131
- "string": "Index out of bounds"
132
- },
133
- "17843811134343075018": {
134
- "error_kind": "string",
135
- "string": "Stack too deep"
136
- }
137
- }
138
- },
139
- "bytecode": "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",
140
- "debug_symbols": "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",
141
- "brillig_names": [
142
- "public_dispatch"
143
- ]
144
- },
145
- {
146
- "name": "consume",
147
- "is_unconstrained": true,
148
- "custom_attributes": [
149
- "public"
150
- ],
151
- "abi": {
152
- "parameters": [
153
- {
154
- "name": "on_behalf_of",
155
- "type": {
156
- "kind": "struct",
157
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
158
- "fields": [
81
+ },
159
82
  {
160
- "name": "inner",
161
- "type": {
162
- "kind": "field"
163
- }
164
- }
165
- ]
166
- },
167
- "visibility": "private"
168
- },
169
- {
170
- "name": "inner_hash",
171
- "type": {
172
- "kind": "field"
173
- },
174
- "visibility": "private"
175
- }
176
- ],
177
- "return_type": {
178
- "abi_type": {
179
- "kind": "field"
180
- },
181
- "visibility": "public"
182
- },
183
- "error_types": {
184
- "206160798890201757": {
185
- "error_kind": "string",
186
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
187
- },
188
- "715723737710351018": {
189
- "error_kind": "string",
190
- "string": "rejecting all"
191
- },
192
- "5019202896831570965": {
193
- "error_kind": "string",
194
- "string": "attempt to add with overflow"
195
- },
196
- "12737498021964987455": {
197
- "error_kind": "string",
198
- "string": "unauthorized"
199
- },
200
- "14225679739041873922": {
201
- "error_kind": "string",
202
- "string": "Index out of bounds"
203
- },
204
- "17843811134343075018": {
205
- "error_kind": "string",
206
- "string": "Stack too deep"
207
- }
208
- }
209
- },
210
- "bytecode": "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",
211
- "debug_symbols": "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",
212
- "brillig_names": [
213
- "consume"
214
- ]
215
- },
216
- {
217
- "name": "is_reject_all",
218
- "is_unconstrained": true,
219
- "custom_attributes": [
220
- "public",
221
- "view"
222
- ],
223
- "abi": {
224
- "parameters": [
225
- {
226
- "name": "on_behalf_of",
227
- "type": {
228
- "kind": "struct",
229
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
230
- "fields": [
231
- {
232
- "name": "inner",
233
- "type": {
234
- "kind": "field"
235
- }
236
- }
237
- ]
238
- },
239
- "visibility": "private"
240
- }
241
- ],
242
- "return_type": {
243
- "abi_type": {
244
- "kind": "boolean"
245
- },
246
- "visibility": "public"
247
- },
248
- "error_types": {
249
- "206160798890201757": {
250
- "error_kind": "string",
251
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
252
- },
253
- "5019202896831570965": {
254
- "error_kind": "string",
255
- "string": "attempt to add with overflow"
256
- },
257
- "9474245853673257536": {
258
- "error_kind": "string",
259
- "string": "Function is_reject_all can only be called statically"
260
- },
261
- "14225679739041873922": {
262
- "error_kind": "string",
263
- "string": "Index out of bounds"
264
- },
265
- "17843811134343075018": {
266
- "error_kind": "string",
267
- "string": "Stack too deep"
268
- }
269
- }
270
- },
271
- "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACSR4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAnInAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGLQ0EBQAoBQIFLQ4FBCsCAAUAAAAAAAAAAAIAAAAAAAAAAC0IAQYnAgcEBQAQAQcBJwMGBAEAKAYCBy0MBwgtDgIIACgIAggtDgIIACgIAggtDgIIACgIAggtDgUILQ0EBQAoBQIFLQ4FBC0NBgUAKAUCBS0OBQYtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAAChC0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAoQtBAAALQ0HAQsoAAGARAADJAIAAwAAAeInAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADsi0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIzJQAABMUvDAADAAEcDAEDARwMAwIAHAwCAQEmKACABAR4AA0AAACABIADJACAAwAAAnEqAQABBfeh86+lrdTKPAEBAiYqAQABBYN7SGg+6XpAPAEBAiYlAAACSS0NAwYtDQQHCygAB4BEAAgkAgAIAAACqicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAz4jAAACvy0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAAuklAAAE1y4EAAaAAygAgAQEAAQlAAAE6S4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAMpJQAABXctDgoBLQ4HAi0OBQMtDgkEIwAAA7EnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADsi0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABOkuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOxJiUAAAJJLgiARQAFIwAAA8INKAAFgEMABiQCAAYAAAQyIwAAA9ctDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEUCMAAAS8LQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAE6S4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAAS8LQwGBSMAAAPCKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAFBCMAAAUPLgCAA4AFIwAABXYuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFYi4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFMSgBgAUEAAEDAIAGAAKABiMAAAV2JioBAAEFRafKcRlB5BU8AQECJg==",
272
- "debug_symbols": "7Z3bbts8DMffJde5EKkj9yofPgxpmw4BgrRI2wFD0Xefk8WHRIxVU8EOMG+GeePfon6WRYmKpffFw/ru7dvXze7x6WXx5b/3xfbpfvW6edo1V+8fy8XdfrPdbr59Hf7zwhz+AENHwcvzane4fnld7V8XXwA9wnKx3j0c/+5sc5PHzXbdXBn3sczsY3Ofk3ls7DvrQIwxYcCTMWE6M/5/uQBwn/HIn3l01JFMh8LyLAp1kdO5lOxJ5ujA+KTyhiEIJrTGADB4OMFy1j6cjNFgZ2sPjyl/kOR8+yCJ+jtjSoy1jab12fYuI+cyIrQ3RrR23Ni7eLL1Lg1ND/wcKr8qfkH51fDzoPyq+Gn7q+IXtP3V8dP2V8UvGuVXxc8pvyp+pPxq+CWr/Kr4JeVXw490/lbkl9oUgk+Y8dPxSw0/NDp+ruPnlV+BX+hsw7npgR/q+1vFz+r8o46fvr9V/Jy2vzp+2v6q+Hltf3X8nPKr4qfz3yp+QfMvdfx0/byKX9T8Sx0/nb9V8Uuaf6njp+NnBoouCuVQyCmUHIoOXzMo1uiYgIGiA80cCmj0ZqBoSM6hoOapGCgakhkoGpJzKFbTRAwUDck5FKchmYGiWZocitdhPgNFW0oORT8y4KDMM/pYaF1Gi+ESykyXEwpQ5tmnjENJ85wQFqA4hZJDmeeEcBzKTH83X4CiHW0Gxc30F+4FKNpSciigIZmBMs9sfgHKPBfYx6HgPHO0BSg6S86hWA3JDBTtaBko2tHmUJxTKDkUbSk5FD/PkBxda4vRy42PBOcZv6cQhJBcW79oLr+QdmGece2GBKO+xbUE55lCvSHBNM986ySCkdqNXiBBFouTRpJKgjTPaeMtCWosriU4z2nG7Qh6o6OZWoIaSSoJgo5maglqG6wkiDqaqSWoo5kiQbJd/chlBGf6WcUtCd6gH4SU2hJweEQGS9B7ap0PCftbg4kcw9DuXRhjv/coRDw6f4vDI/6Y87fY+enPOZ/+Yec/sWcP2pLz3bsNTbrprAjGHd/lpmIwhQN1ou38iA5x3LjpsWLoHHGGhubHutJvr2vs64pm3H0f27ODfOpdt84eff/E3up/r+//LvfAL0WC6aIOmIHqVyAJ/FJdScRGHwDv+opfpnIDvyBTEPFrECVREoj4THPT23XvKZpLEJFPKoDrT58adgWtKApE/Cf/JZGXiEggQkmdrhzeNS7id/4siXgQ3nUtwke4FPFnDJVESSDiI1tJRAIR3zeXRJKS0pU6UTesDXD5cVckkIjCdFEyTiIigQisRBQFIhTQS/xOzmD76Yf1mIm8REQCkbMSURSIrrzuBZEERJAgD6KSJMijBHmUIE9XkIduhmETZKIoEPG7cJVENF1ExgtEYCSiJBChIOYSv1t+QWSNRCQpKbB1aqZs3cD68vdVxEcn6nJKFEMmiZMlfDgbl/jpEsG4H8yVAFhSJYkKrEglKgtFZaGoLCsqy4rKcqLn5URleVG9rswKCyp+k4OiyotUojeFHzOPdS+NhuVO2GYGyOWa6X0SAP8Wj5YDZrpvwK9cFjRhuobfr2ycAfrpGisox/KsU9sOzhYLWg1N1zhBOfx7PqgPo/GC9uZpuoY/63NcE0GgidM1fNanoBGUQ4L6kKBd0/Tng2ZiO/horr6v9pvV3XZ9Otv+8W13Pzjq/vXH8/ri1Pvn/dP9+uFtvz6cf98ffX94DdGlJQY69oHNZfMgl4B4rM7hf5sFNozYlNqU/BM=",
273
- "brillig_names": [
274
- "is_reject_all"
275
- ]
276
- },
277
- {
278
- "name": "sync_notes",
279
- "is_unconstrained": true,
280
- "custom_attributes": [
281
- "aztec::macros::functions::utility"
282
- ],
283
- "abi": {
284
- "parameters": [],
285
- "return_type": null,
286
- "error_types": {
287
- "17843811134343075018": {
288
- "error_kind": "string",
289
- "string": "Stack too deep"
290
- }
291
- }
292
- },
293
- "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
294
- "debug_symbols": "rZLdCoMgGIbvxeMO/P/ZrYwxrCwEsbAajOjeZ2EsarSTTj789OHjUd8RlCYf6qf1VdOB230Eril0bxsfu3HKQB6sc7Z+brcBnAsiC9+12s9t1+vQgxuCFMkMGF8uayHijMo6s3RTduCF5ImW83liBfqBMswSyhj8jqV8emQA0StsJBGrDVPnNpSohFIuDzbsEhtJVxslz204XN+GY36w4VfYKIwTrQj7YyNhQgXc/dQU25cOVufOpIhVgy82ievfrdmFrw1NYcohmDmGmwTGeo93wCSOjaM/",
295
- "brillig_names": [
296
- "sync_notes"
297
- ]
298
- },
299
- {
300
- "name": "set_reject_all",
301
- "is_unconstrained": true,
302
- "custom_attributes": [
303
- "public"
304
- ],
305
- "abi": {
306
- "parameters": [
307
- {
308
- "name": "reject",
309
- "type": {
310
- "kind": "boolean"
311
- },
312
- "visibility": "private"
313
- }
314
- ],
315
- "return_type": null,
316
- "error_types": {
317
- "206160798890201757": {
318
- "error_kind": "string",
319
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
320
- },
321
- "5019202896831570965": {
322
- "error_kind": "string",
323
- "string": "attempt to add with overflow"
324
- },
325
- "14225679739041873922": {
326
- "error_kind": "string",
327
- "string": "Index out of bounds"
328
- },
329
- "17843811134343075018": {
330
- "error_kind": "string",
331
- "string": "Stack too deep"
332
- }
333
- }
334
- },
335
- "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcBLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAi4eAgACAScCAwAALQgBBCcCBQQEABABBQEnAwQEAQAoBAIFLQwFBi0OAwYAKAYCBi0OAwYAKAYCBi0OAwYtDQQFACgFAgUtDgUEKwIABQAAAAAAAAAAAgAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OAwgAKAgCCC0OAwgAKAgCCC0OAwgAKAgCCC0OBQgtDQQFACgFAgUtDgUELQ0GBQAoBQIFLQ4FBi0IAQUAAAECAS0OBAUtCAEEAAABAgEtDgYELQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARAAHJwIIAAEnAgkECi0IAAotDAULLQwEDC0MBg0tDAcOLQwIDwAQAAkAJQAAAlctBAAAJwIIBAktCAAJLQwFCi0MBAstDAYMLQwHDS0MAg4AEAAIACUAAAJXLQQAAC0NBwILKAACgEQACCQCAAgAAAHRJwIJBAA8CQEJJwICBAgtCAAILQwFCS0MBAotDAYLLQwHDAAQAAIAJQAAA4UtBAAALQ0EAgEoAAKARgAFLQ0FBAo4BAMCCygAAoBEAAMkAgADAAACIiUAAASYHAwBAgAwDAACAAQmKACABAR4AA0AAACABIADJACAAwAAAlYqAQABBfeh86+lrdTKPAEBAiYlAAACLi0NAwYtDQQHCygAB4BEAAgkAgAIAAACfScCCQQAPAkBCQsoAAaAQwAHJAIABwAAAxEjAAACki0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAArwlAAAEqi4EAAaAAygAgAQEAAQlAAAEvC4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAL8JQAABUotDgoBLQ4HAi0OBQMtDgkEIwAAA4QnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADhS0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABLwuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOEJiUAAAIuLgiARQAFIwAAA5UNKAAFgEMABiQCAAYAAAQFIwAAA6otDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEIyMAAASPLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAEvC4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAASPLQwGBSMAAAOVKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAE1yMAAATiLgCAA4AFIwAABUkuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFNS4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFBCgBgAUEAAEDAIAGAAKABiMAAAVJJioBAAEFRafKcRlB5BU8AQECJg==",
336
- "debug_symbols": "7Z3Rbts6DIbfJde5ECVKovoqBwdD2qZDgCAt0nbAUPTd52Sxk0aUBVPBhsG8GZaWv0V/lUWKjqSPxeP6/v37t83u6fl1cfffx2L7/LB62zzvuk8fn8vF/X6z3W6+f7v88cIc/gEwR8Hry2p3+Pz6ttq/Le4gmbBcrHePh/9a7C7xtNmuF3fefC4zYySHJ2MktINxSIwx+WhPxuQpXhr/v+zc8aw7RDi4Y/y4O2CC640B3GAMwXHWvr9Ra86uO+sZ25jQn4xjSucrWyLG2kXTU3FngpZz2VroL2ytc+PGHuPJ1iNdmh74WaP8mvih8mvil5RfCz+n/a+Nn/a/Jn6o/a+NHym/Fn7eKr8mflH5tfALoPya+AXl18Iv6vytyo+g50c244fKr4mf5s9N/Mgpvwq/MNiGr6YdP2v0+W3jp/OPJn6gz28bP+1/Tfys9r82ftr/mvg5rb+08dP5bxM/1PpLGz99f97Ez2v9pY0fKr8mflp/aeIXNH9moOhLoRxK1EyXgaLpaw6FNCdgoGiiyUDR6J1DSRqSGShap8qgOKMhmYGiITmHAlomYqBoSGagaEjOoegqBwaK0zSfgaI9hYGiY0oOZaZvHhz0LnfvTsM1lJm+TqhA0Z7CQJnnmDIOZabV/AqUeVbzx6HEeU4IK1B0oGWg6ECbQyFUKDkU7Sk5lJlW8ytQ5lnNH4WCM63mV6DMs5o/DgV0lsxA0ZDMQNGBNodidaBloOgsOYcy09UdFSjzDMkRe1sbvdz4QBDnGb+nEIRwhhGNzQjOM67dkKDXp7iR4Ey3vrklwXnWWycRjKnf/QYIslg80+1vbkkQlWAjQY3FjQRpntOMWxLUbKaRYNJI0kpQs5k2gt5oH2wliEqwkaBmM1WCyQ33lzAjCBqLGwne4lCKzro3tugrBL1PvfOBLo4vARM5hqHf0DHG84asEO1v5/0/7Lxz/7Dzt9gL6O85Xx81Lr5DzzuPpm8BuvdZX5rIrcnE/hkkQ+dLs6fw4OAGpvOFHbqj7x7+uO8uDL57Gvc9kks9eEpm3BgAyQ9Dr794+/P7wKFQyDDMMPqBoXQ1oIVCUB0XAT8rBj9QPcL5KioMnRURCUSFoaIi4t+yAg2nR1mTgfC8e2gvekzWUrASURCICjXIiggFIpLcE0WBqDCXGxXFwvTF49AjfIRMFASiwq6rFREJRIWVjxVREoicpCVXuKc0pFcBrldexUKoGRcVxviKKAlEASUiCYjClj4VkYReYfcTd06Dnc+ep0JJqiJCiYimi6jwfc2KKAhEYCQiAXKykpYsSkQS5E6CvPB9FReGTNfR9cBCaCWiJBAVdgAcFwUjEXmBKDqJSBBziUAiEgRqSoKWErD3FEOfwnbj9rWEj05pqG2keD31T3y/G5eEyRJ+me24RJD3p0L8GxcVFjFWRIIZRoqSlqKkJZK0RJKWkqSlJPg7gTFOpCKJqjAZrKmCRFUIgjUVilRp6qgChp95JtvP2xMymslDERj+6R1vJwh84xfojmv49asVjZ/OgIxAI2mHZ019P/hSqz5p+FS3opneDvDP+cX9cJrp/Q34FRzjGgsCTZiucVagidM1KGgHBfczPQM4VLYEmon94LP79GO136zut+vTYexP77uHi7PZ336+rK+OaX/ZPz+sH9/368OB7eez2g+3aLvh1wY49v3uY/fHX3Z1uaNrh98G2/0Wu1a7ln8B",
337
- "brillig_names": [
338
- "set_reject_all"
339
- ]
340
- },
341
- {
342
- "name": "utility_is_consumable",
343
- "is_unconstrained": true,
344
- "custom_attributes": [
345
- "utility"
346
- ],
347
- "abi": {
348
- "parameters": [
349
- {
350
- "name": "on_behalf_of",
351
- "type": {
352
- "kind": "struct",
353
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
354
- "fields": [
355
- {
356
- "name": "inner",
357
- "type": {
358
- "kind": "field"
359
- }
360
- }
361
- ]
362
- },
363
- "visibility": "private"
364
- },
365
- {
366
- "name": "message_hash",
367
- "type": {
368
- "kind": "field"
369
- },
370
- "visibility": "private"
371
- }
372
- ],
373
- "return_type": {
374
- "abi_type": {
375
- "kind": "boolean"
376
- },
377
- "visibility": "public"
378
- },
379
- "error_types": {
380
- "206160798890201757": {
381
- "error_kind": "string",
382
- "string": "Storage slot 0 not allowed. Storage slots must start from 1."
383
- },
384
- "5019202896831570965": {
385
- "error_kind": "string",
386
- "string": "attempt to add with overflow"
387
- },
388
- "14225679739041873922": {
389
- "error_kind": "string",
390
- "string": "Index out of bounds"
391
- },
392
- "17843811134343075018": {
393
- "error_kind": "string",
394
- "string": "Stack too deep"
395
- }
396
- }
397
- },
398
- "bytecode": "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",
399
- "debug_symbols": "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",
400
- "brillig_names": [
401
- "utility_is_consumable"
402
- ]
403
- },
404
- {
405
- "name": "set_authorized_private",
406
- "is_unconstrained": false,
407
- "custom_attributes": [
408
- "private"
409
- ],
410
- "abi": {
411
- "parameters": [
412
- {
413
- "name": "inputs",
414
- "type": {
415
- "kind": "struct",
416
- "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs",
417
- "fields": [
418
- {
419
- "name": "call_context",
83
+ "name": "historical_header",
420
84
  "type": {
421
85
  "kind": "struct",
422
- "path": "authwit::aztec::protocol_types::abis::call_context::CallContext",
86
+ "path": "authwit::aztec::protocol_types::block_header::BlockHeader",
423
87
  "fields": [
424
88
  {
425
- "name": "msg_sender",
89
+ "name": "last_archive",
426
90
  "type": {
427
91
  "kind": "struct",
428
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
92
+ "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
429
93
  "fields": [
430
94
  {
431
- "name": "inner",
95
+ "name": "root",
432
96
  "type": {
433
97
  "kind": "field"
434
98
  }
99
+ },
100
+ {
101
+ "name": "next_available_leaf_index",
102
+ "type": {
103
+ "kind": "integer",
104
+ "sign": "unsigned",
105
+ "width": 32
106
+ }
435
107
  }
436
108
  ]
437
109
  }
438
110
  },
439
111
  {
440
- "name": "contract_address",
112
+ "name": "content_commitment",
441
113
  "type": {
442
114
  "kind": "struct",
443
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
115
+ "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment",
444
116
  "fields": [
445
117
  {
446
- "name": "inner",
118
+ "name": "num_txs",
119
+ "type": {
120
+ "kind": "field"
121
+ }
122
+ },
123
+ {
124
+ "name": "blobs_hash",
125
+ "type": {
126
+ "kind": "field"
127
+ }
128
+ },
129
+ {
130
+ "name": "in_hash",
131
+ "type": {
132
+ "kind": "field"
133
+ }
134
+ },
135
+ {
136
+ "name": "out_hash",
447
137
  "type": {
448
138
  "kind": "field"
449
139
  }
@@ -452,101 +142,13 @@
452
142
  }
453
143
  },
454
144
  {
455
- "name": "function_selector",
145
+ "name": "state",
456
146
  "type": {
457
147
  "kind": "struct",
458
- "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector",
148
+ "path": "authwit::aztec::protocol_types::state_reference::StateReference",
459
149
  "fields": [
460
150
  {
461
- "name": "inner",
462
- "type": {
463
- "kind": "integer",
464
- "sign": "unsigned",
465
- "width": 32
466
- }
467
- }
468
- ]
469
- }
470
- },
471
- {
472
- "name": "is_static_call",
473
- "type": {
474
- "kind": "boolean"
475
- }
476
- }
477
- ]
478
- }
479
- },
480
- {
481
- "name": "historical_header",
482
- "type": {
483
- "kind": "struct",
484
- "path": "authwit::aztec::protocol_types::block_header::BlockHeader",
485
- "fields": [
486
- {
487
- "name": "last_archive",
488
- "type": {
489
- "kind": "struct",
490
- "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
491
- "fields": [
492
- {
493
- "name": "root",
494
- "type": {
495
- "kind": "field"
496
- }
497
- },
498
- {
499
- "name": "next_available_leaf_index",
500
- "type": {
501
- "kind": "integer",
502
- "sign": "unsigned",
503
- "width": 32
504
- }
505
- }
506
- ]
507
- }
508
- },
509
- {
510
- "name": "content_commitment",
511
- "type": {
512
- "kind": "struct",
513
- "path": "authwit::aztec::protocol_types::content_commitment::ContentCommitment",
514
- "fields": [
515
- {
516
- "name": "num_txs",
517
- "type": {
518
- "kind": "field"
519
- }
520
- },
521
- {
522
- "name": "blobs_hash",
523
- "type": {
524
- "kind": "field"
525
- }
526
- },
527
- {
528
- "name": "in_hash",
529
- "type": {
530
- "kind": "field"
531
- }
532
- },
533
- {
534
- "name": "out_hash",
535
- "type": {
536
- "kind": "field"
537
- }
538
- }
539
- ]
540
- }
541
- },
542
- {
543
- "name": "state",
544
- "type": {
545
- "kind": "struct",
546
- "path": "authwit::aztec::protocol_types::state_reference::StateReference",
547
- "fields": [
548
- {
549
- "name": "l1_to_l2_message_tree",
151
+ "name": "l1_to_l2_message_tree",
550
152
  "type": {
551
153
  "kind": "struct",
552
154
  "path": "authwit::aztec::protocol_types::abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot",
@@ -1991,12 +1593,301 @@
1991
1593
  }
1992
1594
  ]
1993
1595
  },
1994
- "visibility": "databus"
1995
- },
1596
+ "visibility": "databus"
1597
+ },
1598
+ "error_types": {
1599
+ "4939791462094160055": {
1600
+ "error_kind": "string",
1601
+ "string": "Message not authorized by account"
1602
+ },
1603
+ "5019202896831570965": {
1604
+ "error_kind": "string",
1605
+ "string": "attempt to add with overflow"
1606
+ },
1607
+ "14225679739041873922": {
1608
+ "error_kind": "string",
1609
+ "string": "Index out of bounds"
1610
+ },
1611
+ "17843811134343075018": {
1612
+ "error_kind": "string",
1613
+ "string": "Stack too deep"
1614
+ }
1615
+ }
1616
+ },
1617
+ "bytecode": "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",
1618
+ "debug_symbols": "7Vvbbts4EP0XPfuBM5wb8yuLosjFLQwESZDLAosg/75kWlKyQ0klYidurJcglOdQnHOG4gwpPXdX64unn983Nz9uH7qzf56769vL88fN7U1sPXdAr9ce7s5vUvPh8fz+sTtDJl1165ur+K8Avqy6H5vrdXcGjl5Wb62RXLZG6a2VK8beBf5t7EFs2hg4QLaO/2NvjmY1e2HL5qJarL2r9u7FZ2sCt2X9bdUBL9SMUSMLNWPU6JFTw9hTIzJDDQJKHgkQv5MaW6gZoyZUqSGDnho/Qw0B0G9rAu5vER2Pd0B38DtA7Q5eJWQNDHtSE7zCklG+A/hgA3OsmQfpJ3oQw2lzwzJ8Q4YZfTVQ7ltDwBlrX2KHYBA5rho5aJkS9A5nrCFGcaFk+CyrWzssQeyEt6yTRrhodPQa+UWjP9NIoTyB1bs51lXLE1gDvlMjWjQ6eo14DxpFNsqy7dhmNCLrnwNkTHPmZFLM2elwQa1QaVxSnwA6nc0s+ncoi/4nrb8u+p+0/nb0+jNorz/LtP5e8y4F+V5QIH11Nhy/s9IHu8wFOwj2oSBkYafY9O7E/IUv5q8ONt1UjHf9xRPz13+qv+wGj5SquXL2Vm2wk+ZeB09HPvi4GubFkGQ4+GWVfe8q6/nYtQdX1z4N/uNLBHYk/eDVD83TiD4+aWUfoIyIaGZjAR1g2a93OPeYXGZI522R9KtJGhZJv5ik9PEFRZTReknVTZvH48nsLYdBClZPN41LZRkGuSnwL2fhyJ0VZznEBAbHL/WNkZSL57BJqftObk14Ut7WKwnzGeTjScKMtzF8SoYFNjhrSMi3fYvP3HgFmE6ZP/XlDKKFm1FueOFmlBtZuBnlRo+dm897rYds4WaUm7BwM8YNu31w02csEHyY4WbqcIFhD8MJ1EsVgkwPB0LMcUsCK8Dvy4kY/3YH/Mc7oOiKAzbYqKo6ELgsQDBYf9JM+BZbF/eb6+vNz+9b75679KeedrDPxS6r7IZjfTWehmg7xNohoRESW5As6698ic96meMB0I+/gTQN4XaItEO0HWLtkCrVhgVCtgupHxlOQ6Adgu0Q3w6hdgi3Q6rqm5W9ohC2ILUlt7yArf0eVFz8xve699e9Hbb7cNDu6/tR++seDts9HrZ7f9juaY/dm3/TPR+2ezls99VZG0r2G7zuPkfqS+k0JDRD6knzNATaIdgO8e0QaoYIt0OkHdKuvrSrL+3qa7v62q6+Yv0rmjxfUHR3vqhvh1A7pP6xopZDoPBmIqu0Q7QdYu2Q0Awx1w6BRkhs4WuyXgVK2S2Q4HYLg/pnN9MQ3w6hdgi3Q6QREls+WY58amyQ62Q0GUDTSVVs0VIkxuXglb8qkLQQj/SyXXfH5r/n95vzi+t1KrjTr083l7n+js3H/+7yL7lCv7u/vVxfPd2vU63el+kpGuPuGWH0ANJkY1ixlAL21yVbiU+/pwliurJQ5kyCx0rDhwwntyLuQyNdike/CEXy8RtyQSCsMF56ia7+Dw==",
1619
+ "brillig_names": [
1620
+ "store_in_execution_cache_oracle_wrapper",
1621
+ "call_private_function_internal",
1622
+ "load",
1623
+ "notify_created_nullifier_oracle_wrapper",
1624
+ "store_in_execution_cache_oracle_wrapper",
1625
+ "notify_enqueued_public_function_call_wrapper"
1626
+ ],
1627
+ "verification_key": "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"
1628
+ },
1629
+ {
1630
+ "name": "set_reject_all",
1631
+ "is_unconstrained": true,
1632
+ "custom_attributes": [
1633
+ "public"
1634
+ ],
1635
+ "abi": {
1636
+ "parameters": [
1637
+ {
1638
+ "name": "reject",
1639
+ "type": {
1640
+ "kind": "boolean"
1641
+ },
1642
+ "visibility": "private"
1643
+ }
1644
+ ],
1645
+ "return_type": null,
1646
+ "error_types": {
1647
+ "206160798890201757": {
1648
+ "error_kind": "string",
1649
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1650
+ },
1651
+ "5019202896831570965": {
1652
+ "error_kind": "string",
1653
+ "string": "attempt to add with overflow"
1654
+ },
1655
+ "14225679739041873922": {
1656
+ "error_kind": "string",
1657
+ "string": "Index out of bounds"
1658
+ },
1659
+ "17843811134343075018": {
1660
+ "error_kind": "string",
1661
+ "string": "Stack too deep"
1662
+ }
1663
+ }
1664
+ },
1665
+ "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcBLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAgceAgACAScCAwAALQgBBCcCBQQEABABBQEnAwQEAQAoBAIFLQwFBi0OAwYAKAYCBi0OAwYAKAYCBi0OAwYrAgAFAAAAAAAAAAACAAAAAAAAAAAtCAEGJwIHBAUAEAEHAScDBgQBACgGAgctDAcILQ4DCAAoCAIILQ4DCAAoCAIILQ4DCAAoCAIILQ4FCC0IAQUAAAECAS0OBAUtCAEEAAABAgEtDgYELQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARAAHJwIIAAEnAgkECi0IAAotDAULLQwEDC0MBg0tDAcOLQwIDwAQAAkAJQAAAjAtBAAAJwIIBAktCAAJLQwFCi0MBAstDAYMLQwHDS0MAg4AEAAIACUAAAIwLQQAAC0NBwILKAACgEQACCQCAAgAAAGqJwIJBAA8CQEJJwICBAgtCAAILQwFCS0MBAotDAYLLQwHDAAQAAIAJQAAA14tBAAALQ0EAgEoAAKARgAFLQ0FBAo4BAMCCygAAoBEAAMkAgADAAAB+yUAAARxHAwBAgAwDAACAAQmKACABAR4AA0AAACABIADJACAAwAAAi8qAQABBfeh86+lrdTKPAEBAiYlAAACBy0NAwYtDQQHCygAB4BEAAgkAgAIAAACVicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAuojAAACay0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAApUlAAAEgy4EAAaAAygAgAQEAAQlAAAElS4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAALVJQAABSMtDgoBLQ4HAi0OBQMtDgkEIwAAA10nAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADXi0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABJUuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAANdJiUAAAIHLgiARQAFIwAAA24NKAAFgEMABiQCAAYAAAPeIwAAA4MtDQEFLQ0CBi0NAwctDQQILQ0GCQAoCQIJLQ4JBicCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAD/CMAAARoLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAElS4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAARoLQwGBSMAAANuKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAEsCMAAAS7LgCAA4AFIwAABSIuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFDi4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAE3SgBgAUEAAEDAIAGAAKABiMAAAUiJioBAAEFRafKcRlB5BU8AQECJg==",
1666
+ "debug_symbols": "7Z3dbiI9DIbvhWMO8uc46a18+rSiLV0hIVrRdqVV1XvfDMsMbMepFwetVMUnFRS/xPOQiR3PJPO2uF/fvn7/ttk9PD4vbv57W2wf71Yvm8ddeff2vlzc7jfb7eb7t/N/L8zwx1pzEDw/rXbD++eX1f5lcWOzicvFenc/vHShfMXDZrte3IB5X86MwSRzNC4v02QcM2GcwMLROIE358b/L4s7QLqTUpjcMfC5O9ZEPxpb6ydjGz1lDeOBOuMmW++AsMUcRt8x55O1Gw56Zu3BHY2DjSdbQ9k6m+3ohjOZsQaXR95nBAfbAaEzirAVYVCErQizImxE6LUXNiPUXtiKMGgvbEaYFGEjQnCKsBUhKsJGhNEqwlaEURE2IkSd4P0FwoxH42hhhjDridyMUCs1jQid0RO5GaH2wlaEVnthM0Lthc0ItVLTitB5RdiKUCs1rQi9VmqaEWqlphVh0AleM0Kt1LQiBE2tPyI8YAmKhcKiKTCFJWpaS2LRJIHCgpp+klg0mFNYkgZoEovWsygsetWIxqK9hcDi9eoOjaXTSOTSeE3f+TM/Riy207GFw6K9hcLS6z3+HJagWCgsnV7VYLD0eqWCw6JDLoUl6JBLYuk0+Wew9Fr557BogCaxdFr5Z7D0WvnnsHRa+WewoM6gSSwaoEksOuRSWJIOuSQWnUFTWLL2FhJLpwEa7eQGfli3dpl1gRhMp+H8Iog2xnHrHRsxzSF2GuWuCtHq6dwO0XVabL0uxE5Ls5dBRJyOEPMsOgevgeUKEDudVV4Xokbndoih0znIdSFqitMOETSwXAGipjjtEHvdp+i6EDXFuQJETXH+AmI2ecLh5hBRo3M7xHSFMbFYj8YuAAMRII+T+ZjO9tC2BimMcbxrGs8m/hbdb+fjF3Y+h6/rPBj3lZ3nBw7vGedLIX40Dg7/aGJunbwdT8Lk3enmf3Ir+DC5EfLpi33wB9+t+9e+u+Qm30343Pdk0rSNvfXxc2Nro3HT6BuDPzcfjrWSahg3qUycrS6HSmxlVEjPl62fKo82zCqPUBk9OVWWqCrjBaeiL9HaeCKfZjRiZdshPy3rLy9nbcXKTjucCiWqSrmSU4FEFUTHVdnemFFVJnqMqjKzATf1DQg4V6FEhUGkyhJVZcUlo8pGpJK1VTmuOGVd5XT/qMJKBGJUlbGfUVUWxXAqEKlENLwXqUQMK9u3+FOW7N3s/MJKDYtTgUiVJarKTaGcCiUqFNFAEfkkaiuJyCcR+SwiX7kZxocpj/MwG22S8RJVZStLTgUSlbMiVZSoKk8C4VSSuJyCE6kk0TyBqC0kjwvDmOiVoW+moaPXqXSRYdZOpvsgo8HLNfTSX0YDAo2AAb2iktEkwbwkV2Ijp0KJqtLHOZWoLRC1BaK2oqitKGoLRb8XitqqxEZOJZlVZzqn/nR0yfSMtQwG41niCM3lZ2Nx3VzcUBEFiSgJRPSKWk4UBSCClYgkLdEr+fJUVsgIhAgEoihpKXIDNCmS9D0EgSg5iQgFouwlonS5yArygiISHJMVZAbWClKDIrq0R7yXtz9W+83qdrs+PmX04XV3d/bQ0ZefT+sPzx992j/ere9f9+vhSaSnh5AO/d55u3TgDr9KeVsgL0tHOPg2fAq+fAql1dLyLw==",
1667
+ "brillig_names": [
1668
+ "set_reject_all"
1669
+ ]
1670
+ },
1671
+ {
1672
+ "name": "is_reject_all",
1673
+ "is_unconstrained": true,
1674
+ "custom_attributes": [
1675
+ "public",
1676
+ "view"
1677
+ ],
1678
+ "abi": {
1679
+ "parameters": [
1680
+ {
1681
+ "name": "on_behalf_of",
1682
+ "type": {
1683
+ "kind": "struct",
1684
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1685
+ "fields": [
1686
+ {
1687
+ "name": "inner",
1688
+ "type": {
1689
+ "kind": "field"
1690
+ }
1691
+ }
1692
+ ]
1693
+ },
1694
+ "visibility": "private"
1695
+ }
1696
+ ],
1697
+ "return_type": {
1698
+ "abi_type": {
1699
+ "kind": "boolean"
1700
+ },
1701
+ "visibility": "public"
1702
+ },
1703
+ "error_types": {
1704
+ "206160798890201757": {
1705
+ "error_kind": "string",
1706
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1707
+ },
1708
+ "5019202896831570965": {
1709
+ "error_kind": "string",
1710
+ "string": "attempt to add with overflow"
1711
+ },
1712
+ "9474245853673257536": {
1713
+ "error_kind": "string",
1714
+ "string": "Function is_reject_all can only be called statically"
1715
+ },
1716
+ "14225679739041873922": {
1717
+ "error_kind": "string",
1718
+ "string": "Index out of bounds"
1719
+ },
1720
+ "17843811134343075018": {
1721
+ "error_kind": "string",
1722
+ "string": "Stack too deep"
1723
+ }
1724
+ }
1725
+ },
1726
+ "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACIh4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAksnAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGKwIABQAAAAAAAAAAAgAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OAggAKAgCCC0OAggAKAgCCC0OAggAKAgCCC0OBQgtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAACXS0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAl0tBAAALQ0HAQsoAAGARAADJAIAAwAAAbsnAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADiy0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIMJQAABJ4vDAADAAEcDAEDARwMAwIAHAwCAQEmKACABAR4AA0AAACABIADJACAAwAAAkoqAQABBfeh86+lrdTKPAEBAiYqAQABBYN7SGg+6XpAPAEBAiYlAAACIi0NAwYtDQQHCygAB4BEAAgkAgAIAAACgycCCQQAPAkBCQsoAAaAQwAHJAIABwAAAxcjAAACmC0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAAsIlAAAEsC4EAAaAAygAgAQEAAQlAAAEwi4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAMCJQAABVAtDgoBLQ4HAi0OBQMtDgkEIwAAA4onAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADiy0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABMIuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOKJiUAAAIiLgiARQAFIwAAA5sNKAAFgEMABiQCAAYAAAQLIwAAA7AtDQEFLQ0CBi0NAwctDQQILQ0GCQAoCQIJLQ4JBicCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEKSMAAASVLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAEwi4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAASVLQwGBSMAAAObKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAE3SMAAAToLgCAA4AFIwAABU8uAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFOy4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFCigBgAUEAAEDAIAGAAKABiMAAAVPJioBAAEFRafKcRlB5BU8AQECJg==",
1727
+ "debug_symbols": "7Z3hTuMwDMffZZ/3IXYSJ75XOZ1OA8Zp0jTQgJNOiHe/dre2g3qEOdVJU/0FUfB/dn9N4sTp2tfF3frm5dfPze7+4Wnx7fvrYvtwu3rePOyao9e35eJmv9luN79+nv554dof4PggeHpc7drjp+fV/nnxDTACLRfr3d3hd5+bD7nfbNfNkQtvy5F98jEezZNP0FsTC8aMrjNmxHxq/GO5AAhfiCi4dxEddKzTodKfR6UuSbqQsz/KAreMj6roBILgqDMGAD+4IC9Zxy4gdNjbeozSheTQX0jmwRpzFqx9xC5moMHWSbYIDF0Y6LhgHZGPxtG7d7YtwoCGsBYhGcJKhBEMYS1Ca4W1CMlaYTVCa4W1CJMzhLUIgyGsRciGsBJh9oawFmE2hJUI2RZ4X0DI6WhMED8iRLCOXI3QKjW1CNE6cjVCa4W1CL21wmqE1gprEQar1FQjjIawEmG0Sk01wmAIaxFapaYWIdkCrxqhVWpqESabWn9EeMBiW0oSlmxTYBGLTWtFLDZJkLBwMCwSFkvmAhbvLEGLWKyeJWGxXSMZi7UWCYvt7shYZpqJmglbF4Y/iaPD4mc6tpSwzHRsKWCZ625JCctMl4olLDNdKhawRBtyRSw25EpYaKbTuRIWay0SlmQJWsQy08p/AUue6W0HJSzBsEhYbAUtYZnrbfElLDbkCliCsyFXxGIraAkLWGsRscw0Qaf+KSaYPnxB6zLrA8SZpvOLIAKR686QUh5BxJlmuUkheuvOE0CcabF1UohhpqXZyyCm1J9h4nF2DpZY6iHGma4qp4Vo2bkeIs10DTItxGAQ6yFaYqmHmGyKMwFEa4n1ELNNcSaAaFOcL0Bk19UTgXEMca5f3pgW4gRjIuTcucAQCxBj5G4xTxmHjwaXJIzU3R6cThb+kLANPjp/xcEDXHPwfMXBY3ngQF8Kvu/eAMm9cyGEk30XfMqx8Ez3RP3z3BJR/ty4iYOHESwinZq35+rdfz9XHM6V6PPwY+rGvZiHm/998P9ij9cbe7he7iTvX4LDTtSkzdHX1+nMywZKKjH/NLm4r/hCGFV8Sd7AKankHYuiijUquSYNQD0NyGMacsEBfP/cgObXsS95hV1SyY8bKKpIo5JvWSuqVOfFXqFKDlQqmUbsuyLEkEYqQJWKNaozr+QoqOSsUVRFjSqofIUz50X9bPd0ZOtUEVWqpFFR1KiSU6lUNOR6SEmVVQz5TP8aVicex/2LSaHKzqlUQaXKGtWZEaCkUtFAUKlUvryKvFeR9yry4Qz5EHpVTGNV1qhi1KjIqVSkUSVQqVijypq8nHPSqBhUKo2vZhovqVLoJnop0EgjZ6+hZMRx7Edug59r5HxX0NDlGrnNFjQKBsSXa+Stk8K6hM/kxoLqTG4sqZJGxSpfrPEFzqFOpvMGOm+QVTLUeTuTIUsy73SyePEo04jk7uK68YxRECnGpjZkhSfShCd355IoKUTyE9YKIDIpRKzxxDLyvsDAadyMQJ4al0QqT6WhWhKBou0BOo0oKUQeNaKsEMnlo5JI4ylqzkkxR2hKX5rrdPEs4a05/L3ab1Y32/Xxna33L7vbk1e4Pv95XH94m+vj/uF2ffeyX7fvdR1e6doGjJ6XSO7Q5ZrDpocvm2t6iK39b7PRgOQbr43nvw==",
1728
+ "brillig_names": [
1729
+ "is_reject_all"
1730
+ ]
1731
+ },
1732
+ {
1733
+ "name": "utility_is_consumable",
1734
+ "is_unconstrained": true,
1735
+ "custom_attributes": [
1736
+ "utility"
1737
+ ],
1738
+ "abi": {
1739
+ "parameters": [
1740
+ {
1741
+ "name": "on_behalf_of",
1742
+ "type": {
1743
+ "kind": "struct",
1744
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1745
+ "fields": [
1746
+ {
1747
+ "name": "inner",
1748
+ "type": {
1749
+ "kind": "field"
1750
+ }
1751
+ }
1752
+ ]
1753
+ },
1754
+ "visibility": "private"
1755
+ },
1756
+ {
1757
+ "name": "message_hash",
1758
+ "type": {
1759
+ "kind": "field"
1760
+ },
1761
+ "visibility": "private"
1762
+ }
1763
+ ],
1764
+ "return_type": {
1765
+ "abi_type": {
1766
+ "kind": "boolean"
1767
+ },
1768
+ "visibility": "public"
1769
+ },
1770
+ "error_types": {
1771
+ "206160798890201757": {
1772
+ "error_kind": "string",
1773
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1774
+ },
1775
+ "5019202896831570965": {
1776
+ "error_kind": "string",
1777
+ "string": "attempt to add with overflow"
1778
+ },
1779
+ "14225679739041873922": {
1780
+ "error_kind": "string",
1781
+ "string": "Index out of bounds"
1782
+ },
1783
+ "17843811134343075018": {
1784
+ "error_kind": "string",
1785
+ "string": "Stack too deep"
1786
+ }
1787
+ }
1788
+ },
1789
+ "bytecode": "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",
1790
+ "debug_symbols": "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",
1791
+ "brillig_names": [
1792
+ "utility_is_consumable"
1793
+ ]
1794
+ },
1795
+ {
1796
+ "name": "is_consumable",
1797
+ "is_unconstrained": true,
1798
+ "custom_attributes": [
1799
+ "public",
1800
+ "view"
1801
+ ],
1802
+ "abi": {
1803
+ "parameters": [
1804
+ {
1805
+ "name": "on_behalf_of",
1806
+ "type": {
1807
+ "kind": "struct",
1808
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1809
+ "fields": [
1810
+ {
1811
+ "name": "inner",
1812
+ "type": {
1813
+ "kind": "field"
1814
+ }
1815
+ }
1816
+ ]
1817
+ },
1818
+ "visibility": "private"
1819
+ },
1820
+ {
1821
+ "name": "message_hash",
1822
+ "type": {
1823
+ "kind": "field"
1824
+ },
1825
+ "visibility": "private"
1826
+ }
1827
+ ],
1828
+ "return_type": {
1829
+ "abi_type": {
1830
+ "kind": "boolean"
1831
+ },
1832
+ "visibility": "public"
1833
+ },
1834
+ "error_types": {
1835
+ "206160798890201757": {
1836
+ "error_kind": "string",
1837
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1838
+ },
1839
+ "5019202896831570965": {
1840
+ "error_kind": "string",
1841
+ "string": "attempt to add with overflow"
1842
+ },
1843
+ "5444967152290923376": {
1844
+ "error_kind": "string",
1845
+ "string": "Function is_consumable can only be called statically"
1846
+ },
1847
+ "14225679739041873922": {
1848
+ "error_kind": "string",
1849
+ "string": "Index out of bounds"
1850
+ },
1851
+ "17843811134343075018": {
1852
+ "error_kind": "string",
1853
+ "string": "Stack too deep"
1854
+ }
1855
+ }
1856
+ },
1857
+ "bytecode": "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",
1858
+ "debug_symbols": "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",
1859
+ "brillig_names": [
1860
+ "is_consumable"
1861
+ ]
1862
+ },
1863
+ {
1864
+ "name": "set_authorized",
1865
+ "is_unconstrained": true,
1866
+ "custom_attributes": [
1867
+ "public"
1868
+ ],
1869
+ "abi": {
1870
+ "parameters": [
1871
+ {
1872
+ "name": "message_hash",
1873
+ "type": {
1874
+ "kind": "field"
1875
+ },
1876
+ "visibility": "private"
1877
+ },
1878
+ {
1879
+ "name": "authorize",
1880
+ "type": {
1881
+ "kind": "boolean"
1882
+ },
1883
+ "visibility": "private"
1884
+ }
1885
+ ],
1886
+ "return_type": null,
1996
1887
  "error_types": {
1997
- "4939791462094160055": {
1888
+ "206160798890201757": {
1998
1889
  "error_kind": "string",
1999
- "string": "Message not authorized by account"
1890
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2000
1891
  },
2001
1892
  "5019202896831570965": {
2002
1893
  "error_kind": "string",
@@ -2012,20 +1903,14 @@
2012
1903
  }
2013
1904
  }
2014
1905
  },
2015
- "bytecode": "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",
2016
- "debug_symbols": "7VvbTus4FP2XPvfB+77Nr4xGR1x6jiohQFxGGiH+fZzO2AnFScaCQg/NC8LtWo73Wk68vZ0+r642F0+/fmxvft4+rM7+eF5d316eP25vb1LreQW8++zh7vymaz48nt8/rs5Q2Narzc1V+lcBX9arn9vrzeoMAr+s36KRQ0aj9miTCphClP/ABOrTYJAIeSDpfwoFju41vIpnuJoVNIVq76SU0QzhFfrP9QpkkWZMGl2kGZPGjlwa4V6aAbwuDQJqHgmwvFMaX6QZkyZWpWGHXhqakYYB8vgZpL9EiiRdAcPBrwC1K5BpzB44auF09IpKzsUDij6AYw0eFbLB6X/HabhjQTsKzvhrkTPaYqQZNFmelkzcY2tBIkGeCkgDRbCuCJV5Q8MxV8Gh3BwQPA7BnT+4+HPU/tDiz//yx/olwGQGDBZLKuCg7/KHF3+O2h/5AH9ixLJMB/EZf9hDLHAfxDoCZ9cCl2DDBbSio0vRMSW009nLqXuvi/cn670t3p+s93703ktfi2ARnfaezIvk0O/G2HbBxuMPVvuJrnMTHRStJM/KA3P/3VBSOLF44ZvFa4PCmqnLfrx4YvHSl8YrYfBIqcJNcrTmg2rZ7klLfOSDTythXghZh4NfVtj3rLAkx+47hLrv3eA/f1sggbUfvNEQ3o3o85NVoQhlRMwzRQQMgKUeH3DuEXnqd4cvdn4nO+Ni5zeykz9/A5Es9N5OC9PwdOSYNwQSBylXPb10KcLEQS4KsssuGY48WA2ep5dCwJkiSJd75znTpep7uTTjSUVb3zk4ZRKlk4KZaNP0KVkV+OAsoWO+7Vspa0MGMJ0if+kLF8yLNqPayKLNqDa6aDOqjR27Nl/3qg77os2oNnHRZkwbCR+hTZ+xQKQ4o83UYYLABwwncm9VjDo9HIgpxy0JrIK8LycS/N0DoM8PwLBsl6IPilPVAKKUl08AfTCB0nxOrYv77fX19tePV++Th+5PPe0QyhtdMd2fjvXVeJpi7RRvp8RGSmpBh6y/zqWU/fIgAyKNv2E0TZF2irZTrJ3i7ZSq1I6Fwr5PqR8RTlOgnYLtFGqncDtF2inaTrF2irdT6u57XrA9xleUWi5Q3va2vsiUVuXxWtDHdQ+H7R4P2z0dtns+bPdy2O71sN3bB3bv9KZ7P2z38aDd15PmWNLySLb/HKknttMUbKdQO4XbKdJO0XaKNVPU2ymxmWLt7lu7+9buvrW7b+3uW/0HiOWQBtX27xfTdoq1U+o/5LJyMhXf3MgWmyke2inQTsF2CrVTuJGSWrjbRVQjUsllAI1hf8dS/53PNIXaKdxOkXaKNlJSizrkyO+aHfIGHl0H1O4ILbV42b2m5WCnX5XIVoRHfnldEEjNv87vt+cX15uuEtB9+3RzmQsDqfn4913+JpcO7u5vLzdXT/ebrojQ1w+62ZjKeowpAuieAgJr0bKz3n2ksFbtvu9ukBjWEcs909HTToNipqczYpZ+anQfga4RiuXjF5TCQFhj+uglhfoP",
1906
+ "bytecode": "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",
1907
+ "debug_symbols": "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",
2017
1908
  "brillig_names": [
2018
- "store_in_execution_cache_oracle_wrapper",
2019
- "call_private_function_internal",
2020
- "load",
2021
- "notify_created_nullifier_oracle_wrapper",
2022
- "store_in_execution_cache_oracle_wrapper",
2023
- "notify_enqueued_public_function_call_wrapper"
2024
- ],
2025
- "verification_key": "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"
1909
+ "set_authorized"
1910
+ ]
2026
1911
  },
2027
1912
  {
2028
- "name": "set_authorized",
1913
+ "name": "public_dispatch",
2029
1914
  "is_unconstrained": true,
2030
1915
  "custom_attributes": [
2031
1916
  "public"
@@ -2033,30 +1918,123 @@
2033
1918
  "abi": {
2034
1919
  "parameters": [
2035
1920
  {
2036
- "name": "message_hash",
1921
+ "name": "selector",
2037
1922
  "type": {
2038
1923
  "kind": "field"
2039
1924
  },
2040
1925
  "visibility": "private"
1926
+ }
1927
+ ],
1928
+ "return_type": null,
1929
+ "error_types": {
1930
+ "206160798890201757": {
1931
+ "error_kind": "string",
1932
+ "string": "Storage slot 0 not allowed. Storage slots must start from 1."
1933
+ },
1934
+ "715723737710351018": {
1935
+ "error_kind": "string",
1936
+ "string": "rejecting all"
1937
+ },
1938
+ "2830029349304997821": {
1939
+ "error_kind": "fmtstring",
1940
+ "length": 27,
1941
+ "item_types": [
1942
+ {
1943
+ "kind": "field"
1944
+ }
1945
+ ]
1946
+ },
1947
+ "5019202896831570965": {
1948
+ "error_kind": "string",
1949
+ "string": "attempt to add with overflow"
1950
+ },
1951
+ "5444967152290923376": {
1952
+ "error_kind": "string",
1953
+ "string": "Function is_consumable can only be called statically"
1954
+ },
1955
+ "6304245522015439386": {
1956
+ "error_kind": "string",
1957
+ "string": "Function _set_authorized can only be called internally"
1958
+ },
1959
+ "9474245853673257536": {
1960
+ "error_kind": "string",
1961
+ "string": "Function is_reject_all can only be called statically"
1962
+ },
1963
+ "12737498021964987455": {
1964
+ "error_kind": "string",
1965
+ "string": "unauthorized"
1966
+ },
1967
+ "14225679739041873922": {
1968
+ "error_kind": "string",
1969
+ "string": "Index out of bounds"
1970
+ },
1971
+ "17843811134343075018": {
1972
+ "error_kind": "string",
1973
+ "string": "Stack too deep"
1974
+ }
1975
+ }
1976
+ },
1977
+ "bytecode": "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",
1978
+ "debug_symbols": "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",
1979
+ "brillig_names": [
1980
+ "public_dispatch"
1981
+ ]
1982
+ },
1983
+ {
1984
+ "name": "consume",
1985
+ "is_unconstrained": true,
1986
+ "custom_attributes": [
1987
+ "public"
1988
+ ],
1989
+ "abi": {
1990
+ "parameters": [
1991
+ {
1992
+ "name": "on_behalf_of",
1993
+ "type": {
1994
+ "kind": "struct",
1995
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
1996
+ "fields": [
1997
+ {
1998
+ "name": "inner",
1999
+ "type": {
2000
+ "kind": "field"
2001
+ }
2002
+ }
2003
+ ]
2004
+ },
2005
+ "visibility": "private"
2041
2006
  },
2042
2007
  {
2043
- "name": "authorize",
2008
+ "name": "inner_hash",
2044
2009
  "type": {
2045
- "kind": "boolean"
2010
+ "kind": "field"
2046
2011
  },
2047
2012
  "visibility": "private"
2048
2013
  }
2049
2014
  ],
2050
- "return_type": null,
2015
+ "return_type": {
2016
+ "abi_type": {
2017
+ "kind": "field"
2018
+ },
2019
+ "visibility": "public"
2020
+ },
2051
2021
  "error_types": {
2052
2022
  "206160798890201757": {
2053
2023
  "error_kind": "string",
2054
2024
  "string": "Storage slot 0 not allowed. Storage slots must start from 1."
2055
2025
  },
2026
+ "715723737710351018": {
2027
+ "error_kind": "string",
2028
+ "string": "rejecting all"
2029
+ },
2056
2030
  "5019202896831570965": {
2057
2031
  "error_kind": "string",
2058
2032
  "string": "attempt to add with overflow"
2059
2033
  },
2034
+ "12737498021964987455": {
2035
+ "error_kind": "string",
2036
+ "string": "unauthorized"
2037
+ },
2060
2038
  "14225679739041873922": {
2061
2039
  "error_kind": "string",
2062
2040
  "string": "Index out of bounds"
@@ -2067,10 +2045,10 @@
2067
2045
  }
2068
2046
  }
2069
2047
  },
2070
- "bytecode": "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",
2071
- "debug_symbols": "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",
2048
+ "bytecode": "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",
2049
+ "debug_symbols": "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",
2072
2050
  "brillig_names": [
2073
- "set_authorized"
2051
+ "consume"
2074
2052
  ]
2075
2053
  },
2076
2054
  {
@@ -2137,11 +2115,33 @@
2137
2115
  }
2138
2116
  }
2139
2117
  },
2140
- "bytecode": "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",
2141
- "debug_symbols": "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",
2118
+ "bytecode": "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",
2119
+ "debug_symbols": "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",
2142
2120
  "brillig_names": [
2143
2121
  "_set_authorized"
2144
2122
  ]
2123
+ },
2124
+ {
2125
+ "name": "sync_notes",
2126
+ "is_unconstrained": true,
2127
+ "custom_attributes": [
2128
+ "aztec::macros::functions::utility"
2129
+ ],
2130
+ "abi": {
2131
+ "parameters": [],
2132
+ "return_type": null,
2133
+ "error_types": {
2134
+ "17843811134343075018": {
2135
+ "error_kind": "string",
2136
+ "string": "Stack too deep"
2137
+ }
2138
+ }
2139
+ },
2140
+ "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
2141
+ "debug_symbols": "rZLdCoMgGIbvxWMP/P/ZrYwxrGwIYmE1GNG9z8JYrNFOOhE/fXh50HcElS2Gx92FuunA5ToC35Smd01I0zhBUETnvXvct8cAzQumC9+1Jsxj15vYgwtGDFMIbKiWvSQpo3beLtMEd7xUItNqvs+sxD9QTnhGOUefWCamGwSYnWGjqFxtuD62YVRnlAm1s+Gn2Ci22mh1bCPQ+jaCiJ2NOMNGE5JpTfkfG4UyKtHXT01pfJroTOFtrlg9hHLTuP7V2q/ytbEpbTVEO9dw08C0XrGChKbYFP0G",
2142
+ "brillig_names": [
2143
+ "sync_notes"
2144
+ ]
2145
2145
  }
2146
2146
  ],
2147
2147
  "outputs": {
@@ -2209,21 +2209,6 @@
2209
2209
  "name": "parameters",
2210
2210
  "type": {
2211
2211
  "fields": [
2212
- {
2213
- "name": "approver",
2214
- "type": {
2215
- "fields": [
2216
- {
2217
- "name": "inner",
2218
- "type": {
2219
- "kind": "field"
2220
- }
2221
- }
2222
- ],
2223
- "kind": "struct",
2224
- "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2225
- }
2226
- },
2227
2212
  {
2228
2213
  "name": "message_hash",
2229
2214
  "type": {
@@ -2238,12 +2223,12 @@
2238
2223
  }
2239
2224
  ],
2240
2225
  "kind": "struct",
2241
- "path": "AuthRegistry::set_authorized_private_parameters"
2226
+ "path": "AuthRegistry::set_authorized_parameters"
2242
2227
  }
2243
2228
  }
2244
2229
  ],
2245
2230
  "kind": "struct",
2246
- "path": "AuthRegistry::set_authorized_private_abi"
2231
+ "path": "AuthRegistry::set_authorized_abi"
2247
2232
  },
2248
2233
  {
2249
2234
  "fields": [
@@ -2252,25 +2237,19 @@
2252
2237
  "type": {
2253
2238
  "fields": [
2254
2239
  {
2255
- "name": "message_hash",
2256
- "type": {
2257
- "kind": "field"
2258
- }
2259
- },
2260
- {
2261
- "name": "authorize",
2240
+ "name": "reject",
2262
2241
  "type": {
2263
2242
  "kind": "boolean"
2264
2243
  }
2265
2244
  }
2266
2245
  ],
2267
2246
  "kind": "struct",
2268
- "path": "AuthRegistry::set_authorized_parameters"
2247
+ "path": "AuthRegistry::set_reject_all_parameters"
2269
2248
  }
2270
2249
  }
2271
2250
  ],
2272
2251
  "kind": "struct",
2273
- "path": "AuthRegistry::set_authorized_abi"
2252
+ "path": "AuthRegistry::set_reject_all_abi"
2274
2253
  },
2275
2254
  {
2276
2255
  "fields": [
@@ -2279,7 +2258,7 @@
2279
2258
  "type": {
2280
2259
  "fields": [
2281
2260
  {
2282
- "name": "approver",
2261
+ "name": "on_behalf_of",
2283
2262
  "type": {
2284
2263
  "fields": [
2285
2264
  {
@@ -2292,27 +2271,21 @@
2292
2271
  "kind": "struct",
2293
2272
  "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2294
2273
  }
2295
- },
2296
- {
2297
- "name": "message_hash",
2298
- "type": {
2299
- "kind": "field"
2300
- }
2301
- },
2302
- {
2303
- "name": "authorize",
2304
- "type": {
2305
- "kind": "boolean"
2306
- }
2307
2274
  }
2308
2275
  ],
2309
2276
  "kind": "struct",
2310
- "path": "AuthRegistry::_set_authorized_parameters"
2277
+ "path": "AuthRegistry::is_reject_all_parameters"
2278
+ }
2279
+ },
2280
+ {
2281
+ "name": "return_type",
2282
+ "type": {
2283
+ "kind": "boolean"
2311
2284
  }
2312
2285
  }
2313
2286
  ],
2314
2287
  "kind": "struct",
2315
- "path": "AuthRegistry::_set_authorized_abi"
2288
+ "path": "AuthRegistry::is_reject_all_abi"
2316
2289
  },
2317
2290
  {
2318
2291
  "fields": [
@@ -2405,7 +2378,7 @@
2405
2378
  "type": {
2406
2379
  "fields": [
2407
2380
  {
2408
- "name": "on_behalf_of",
2381
+ "name": "approver",
2409
2382
  "type": {
2410
2383
  "fields": [
2411
2384
  {
@@ -2418,21 +2391,27 @@
2418
2391
  "kind": "struct",
2419
2392
  "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2420
2393
  }
2394
+ },
2395
+ {
2396
+ "name": "message_hash",
2397
+ "type": {
2398
+ "kind": "field"
2399
+ }
2400
+ },
2401
+ {
2402
+ "name": "authorize",
2403
+ "type": {
2404
+ "kind": "boolean"
2405
+ }
2421
2406
  }
2422
2407
  ],
2423
2408
  "kind": "struct",
2424
- "path": "AuthRegistry::is_reject_all_parameters"
2425
- }
2426
- },
2427
- {
2428
- "name": "return_type",
2429
- "type": {
2430
- "kind": "boolean"
2409
+ "path": "AuthRegistry::_set_authorized_parameters"
2431
2410
  }
2432
2411
  }
2433
2412
  ],
2434
2413
  "kind": "struct",
2435
- "path": "AuthRegistry::is_reject_all_abi"
2414
+ "path": "AuthRegistry::_set_authorized_abi"
2436
2415
  },
2437
2416
  {
2438
2417
  "fields": [
@@ -2441,19 +2420,40 @@
2441
2420
  "type": {
2442
2421
  "fields": [
2443
2422
  {
2444
- "name": "reject",
2423
+ "name": "approver",
2424
+ "type": {
2425
+ "fields": [
2426
+ {
2427
+ "name": "inner",
2428
+ "type": {
2429
+ "kind": "field"
2430
+ }
2431
+ }
2432
+ ],
2433
+ "kind": "struct",
2434
+ "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
2435
+ }
2436
+ },
2437
+ {
2438
+ "name": "message_hash",
2439
+ "type": {
2440
+ "kind": "field"
2441
+ }
2442
+ },
2443
+ {
2444
+ "name": "authorize",
2445
2445
  "type": {
2446
2446
  "kind": "boolean"
2447
2447
  }
2448
2448
  }
2449
2449
  ],
2450
2450
  "kind": "struct",
2451
- "path": "AuthRegistry::set_reject_all_parameters"
2451
+ "path": "AuthRegistry::set_authorized_private_parameters"
2452
2452
  }
2453
2453
  }
2454
2454
  ],
2455
2455
  "kind": "struct",
2456
- "path": "AuthRegistry::set_reject_all_abi"
2456
+ "path": "AuthRegistry::set_authorized_private_abi"
2457
2457
  }
2458
2458
  ]
2459
2459
  }
@@ -2461,7 +2461,7 @@
2461
2461
  "file_map": {
2462
2462
  "104": {
2463
2463
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
2464
- "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_contract_library_method,\n is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n is_fn_view, modify_fn_body, module_has_initializer, 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 transform_utility(f: FunctionDefinition) {\n // Check if function is marked as unconstrained\n if !f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n );\n }\n\n // Create utility context\n let context_creation =\n quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n // Initialize Storage if module has storage\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 utility 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 // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n // body.\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_body(modified_body);\n\n f.set_return_public(true);\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::messages::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::messages::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_private(f)\n & !is_fn_public(f)\n & !is_fn_utility(f)\n & !is_fn_contract_library_method(f)\n & !is_fn_test(f) {\n panic(\n f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n );\n }\n }\n}\n"
2464
+ "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_contract_library_method,\n is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n is_fn_view, modify_fn_body, module_has_initializer, 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 transform_utility(f: FunctionDefinition) {\n // Check if function is marked as unconstrained\n if !f.is_unconstrained() {\n let name = f.name();\n panic(\n f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n );\n }\n\n // Create utility context\n let context_creation =\n quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n let module_has_storage = module_has_storage(f.module());\n\n // Initialize Storage if module has storage\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 utility 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 // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n // body.\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_body(modified_body);\n\n f.set_return_public(true);\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::messages::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::messages::discovery::discover_new_messages(\n context.this_address(),\n _compute_note_hash_and_nullifier,\n );\n };\n }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n for f in m.functions() {\n let name = f.name();\n if !is_fn_private(f)\n & !is_fn_public(f)\n & !is_fn_utility(f)\n & !is_fn_contract_library_method(f)\n & !is_fn_test(f) {\n panic(\n f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n );\n }\n }\n}\n"
2465
2465
  },
2466
2466
  "107": {
2467
2467
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
@@ -2499,9 +2499,9 @@
2499
2499
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
2500
2500
  "source": "use crate::context::{PublicContext, UtilityContext};\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> PublicMutable<T, &mut PublicContext> {\n // docs:start:public_mutable_struct_read\n pub fn read<let T_PACKED_LEN: u32>(self) -> T\n where\n T: Packable<T_PACKED_LEN>,\n {\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<let T_PACKED_LEN: u32>(self, value: T)\n where\n T: Packable<T_PACKED_LEN>,\n {\n self.context.storage_write(self.storage_slot, value);\n }\n // docs:end:public_mutable_struct_write\n}\n\nimpl<T> PublicMutable<T, UtilityContext> {\n pub unconstrained fn read<let T_PACKED_LEN: u32>(self) -> T\n where\n T: Packable<T_PACKED_LEN>,\n {\n self.context.storage_read(self.storage_slot)\n }\n}\n"
2501
2501
  },
2502
- "20": {
2503
- "path": "std/hash/poseidon2.nr",
2504
- "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub(crate) 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(crate) 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(crate) 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(crate) 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"
2502
+ "208": {
2503
+ "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.0/src/poseidon2.nr",
2504
+ "source": "use std::default::Default;\nuse std::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(crate) 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::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"
2505
2505
  },
2506
2506
  "270": {
2507
2507
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
@@ -2509,7 +2509,7 @@
2509
2509
  },
2510
2510
  "288": {
2511
2511
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
2512
- "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"
2512
+ "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 poseidon::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 poseidon::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 = poseidon::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 = poseidon::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"
2513
2513
  },
2514
2514
  "305": {
2515
2515
  "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
@@ -2557,7 +2557,7 @@
2557
2557
  },
2558
2558
  "69": {
2559
2559
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
2560
- "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option<Field>,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n where\n T: Serialize<N>,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call_static(gas_for_call(gas_opts), contract_address, calldata);\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n where\n T: Packable<N>,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n where\n T: Packable<N>,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n // It's ok to use the max possible gas here, because the gas will be\n // capped by the gas left in the (STATIC)CALL instruction.\n [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
2560
+ "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n pub args_hash: Option<Field>,\n pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n pub fn new(compute_args_hash: fn() -> Field) -> Self {\n PublicContext { args_hash: Option::none(), compute_args_hash }\n }\n\n pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n where\n T: Serialize<N>,\n {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n }\n\n pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n }\n\n pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n }\n\n pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n }\n\n pub fn consume_l1_to_l2_message(\n &mut self,\n content: Field,\n secret: Field,\n sender: EthAddress,\n leaf_index: Field,\n ) {\n let secret_hash = compute_secret_hash(secret);\n let message_hash = compute_l1_to_l2_message_hash(\n sender,\n self.chain_id(),\n /*recipient=*/\n self.this_address(),\n self.version(),\n content,\n secret_hash,\n leaf_index,\n );\n let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n assert(\n !self.nullifier_exists(nullifier, self.this_address()),\n \"L1-to-L2 message is already nullified\",\n );\n assert(\n self.l1_to_l2_msg_exists(message_hash, leaf_index),\n \"Tried to consume nonexistent L1-to-L2 message\",\n );\n\n self.push_nullifier(nullifier);\n }\n\n pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { send_l2_to_l1_msg(recipient, content) };\n }\n\n pub unconstrained fn call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call(\n gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n contract_address,\n calldata,\n );\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub unconstrained fn static_call_public_function(\n _self: &mut Self,\n contract_address: AztecAddress,\n function_selector: FunctionSelector,\n args: [Field],\n gas_opts: GasOpts,\n ) -> [Field] {\n let calldata = args.push_front(function_selector.to_field());\n\n call_static(\n gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n contract_address,\n calldata,\n );\n // Use success_copy to determine whether the call succeeded\n let success = success_copy();\n\n let result_data = returndata_copy(0, returndata_size());\n if !success {\n // Rethrow the revert data.\n avm_revert(result_data);\n }\n result_data\n }\n\n pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_note_hash(note_hash) };\n }\n pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { emit_nullifier(nullifier) };\n }\n\n pub fn this_address(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n address()\n }\n }\n pub fn msg_sender(_self: Self) -> AztecAddress {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n sender()\n }\n }\n pub fn selector(_self: Self) -> FunctionSelector {\n // The selector is the first element of the calldata when calling a public function through dispatch.\n // Safety: AVM opcodes are constrained by the AVM itself\n let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n FunctionSelector::from_field(raw_selector[0])\n }\n pub fn get_args_hash(mut self) -> Field {\n if !self.args_hash.is_some() {\n self.args_hash = Option::some((self.compute_args_hash)());\n }\n\n self.args_hash.unwrap_unchecked()\n }\n pub fn transaction_fee(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n transaction_fee()\n }\n }\n\n pub fn chain_id(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n chain_id()\n }\n }\n pub fn version(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n version()\n }\n }\n pub fn block_number(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n block_number()\n }\n }\n pub fn timestamp(_self: Self) -> u64 {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n timestamp()\n }\n }\n pub fn fee_per_l2_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_l2_gas()\n }\n }\n pub fn fee_per_da_gas(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n fee_per_da_gas()\n }\n }\n\n pub fn l2_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n l2_gas_left()\n }\n }\n pub fn da_gas_left(_self: Self) -> Field {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe {\n da_gas_left()\n }\n }\n pub fn is_static_call(_self: Self) -> bool {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { is_static_call() } == 1\n }\n\n pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n let mut out = [0; N];\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n out[i] = unsafe { storage_read(storage_slot + i as Field) };\n }\n out\n }\n\n pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n where\n T: Packable<N>,\n {\n T::unpack(self.raw_storage_read(storage_slot))\n }\n\n pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n for i in 0..N {\n // Safety: AVM opcodes are constrained by the AVM itself\n unsafe { storage_write(storage_slot + i as Field, values[i]) };\n }\n }\n\n pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n where\n T: Packable<N>,\n {\n self.raw_storage_write(storage_slot, value.pack());\n }\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n version_opcode()\n}\nunconstrained fn block_number() -> Field {\n block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(\n l2_gas_allocation: Field,\n da_gas_allocation: Field,\n address: AztecAddress,\n args: [Field],\n) {\n call_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\nunconstrained fn call_static(\n l2_gas_allocation: Field,\n da_gas_allocation: Field,\n address: AztecAddress,\n args: [Field],\n) {\n call_static_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n fn empty() -> Self {\n PublicContext::new(|| 0)\n }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n l2_gas_allocation: Field,\n da_gas_allocation: Field,\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n l2_gas_allocation: Field,\n da_gas_allocation: Field,\n address: AztecAddress,\n args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
2561
2561
  },
2562
2562
  "70": {
2563
2563
  "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",