@aztec/protocol-contracts 0.85.0 → 0.86.0

package/artifacts/Router.json

@@ -3,6 +3,86 @@
   "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
   "name": "Router",
   "functions": [
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "aztec::macros::functions::utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "rZJLioQwFEX38sYZ5P9xK0VTRI1FIESJ2tCIe+9YxELKpnri5JEXDpdDchdoXT0/7j52/QjVbYHQN3byfczbsiKokw/BP+7Ha8DbIOzJj4ON2zpONk1QEcwJQ+Bi+zwrmjM6HxxURq3ohCstC6wxf6GS/4EKKgoqBH6hhJn1CwHhF8hopnYZYT7LcGYKyqU+yYgrZDTfZYz+LCPx/jKSypOMvEDGUFpgw8Q/MhoXVOG3b1rz+m2Tt3VwpV7dHJtD26afwb0Vb0h949o5ua2Ch/bleSMaUZZjc/Qv",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "_check_block_number",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal",
+        "view"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "operation",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 8
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "value",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "1433889167918961673": {
+            "error_kind": "fmtstring",
+            "length": 17,
+            "item_types": []
+          },
+          "2242946026394210301": {
+            "error_kind": "string",
+            "string": "Block number mismatch."
+          },
+          "8209322232883590150": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called internally"
+          },
+          "10421965853029650238": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called statically"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCLgiASQABLgiASgACJQAAAFIlAAAAfSgCAAEEgEsnAgIEADsNAAEAAigAgEMCAAQoAIBEAgAGKACARQIAASgAgEYCAAIoAIBHAgAFKACASAIAAyYlAAADQR4CAAQBHgIABQAKOAQFBiQCAAYAAACeJQAAA2oeAgAECScCBQABCjgEBQYkAgAGAAAAuiUAAAN8HgIABAUKOAQCBQw4BAIGCygAAYBFAAInAgQBASQCAAIAAAMqIwAAAOMLKAABgEYABxYMBQgkAgAHAAADGCMAAAD8CygAAYBIAAkkAgAJAAADBiMAAAERCygAAYBDAAokAgAKAAAC7yMAAAEmCygAAYBHAAoWDAYLJAIACgAAAtgjAAABPwsoAAGARAAIJAIACAAAAsYjAAABVCcCAQJJJwIIAm4nAgoCdicCCwJhJwIMAmwnAg0CaScCDgJkJwIPAiAnAhACbycCEQJwJwISAmUnAhMCcicCFAJ0LQgBFScCFgQSABABFgEnAxUEAQAoFQIWLQwWFy0OARcAKBcCFy0OCBcAKBcCFy0OChcAKBcCFy0OCxcAKBcCFy0ODBcAKBcCFy0ODRcAKBcCFy0ODhcAKBcCFy0ODxcAKBcCFy0OEBcAKBcCFy0OERcAKBcCFy0OEhcAKBcCFy0OExcAKBcCFy0OCxcAKBcCFy0OFBcAKBcCFy0ODRcAKBcCFy0OEBcAKBcCFy0OCBcnAgEBACcCCAQACjgBBAokAgAKAAACvScCCwQTLQgBDCcCDQQTABABDQEtDAwNKgMADQUT5jKZ5RcUCQAoDQINACgVAg4nAg8EES4EAA6AAy4EAA2ABC4EAA+ABSUAAAOOJwIOBBEAOA0ODS0OCA0AKA0CDTwNDAstDAEGIwAAAs8tDAsGIwAAAs8tDAYFIwAAAuYEOAsIAS0MAQUjAAAC5i0MBQkjAAAC/RI4BgUBLQwBCSMAAAL9LQwJByMAAAMPLQwGByMAAAMPLQwHAiMAAAMhLQwIAiMAAAMhLQwCAyMAAAMzLQwFAyMAAAMzJAIAAwAAA0AlAAAD1CYoAIAEBHgADQAAAIAEgAMkAIADAAADaSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFce1fE3G+NAY8AQECJioBAAEFkKJCubMVTz48AQECJgEAgAOABYAHLgCAA4AILgCABIAJCwCACIAHgAokAIAKAAAD0y4BgAiABi4CgAaACQEAgAgAAoAIAQCACQACgAkjAAADoiYqAQABBR8gi4cBmc/9PAEBAiY=",
+      "debug_symbols": "zVrbbuIwEP2XPPPg8VzdX1lVFW3TCglBRelKq6r/vkmLQ0oCLZCR/IISNJNz5uAzNo7fq8f6/u35brF6Wr9WN3/eq+X6Yb5drFfN3fvHrLrfLJbLxfNd/+sqtB+A4TPh9WW+au9ft/PNtroBSAlnVb16bK5jAGge8rRY1tVN0o/ZIJyDhV10c2ldsMSRYGPgXbAxhn7w7awhxKOEGhK6J4R6mhClkKMpgfxAiMgyIRI6JES/UQhTn9BnGl+UxnhZmo2rxiBdGqOdVk2R8y+jqHBatRRDDk4x2qFqgr8gROGwDrGL0vQyNIPL0mQ0TbAbocL7AcphRD1BhF2wIPEPA1QtB5uFeCh1Gq9CYuroqJ2mgyk7gMI+FIy+AORqAIpZUcL4DWBkZKFRHlkUtBc9xhwts0BMveCxAR5TJySGnpCjwQBB8whvrlNfl1aWpiNdL0vXeUjpUPcY9WoAhq4xow4AjvTacwA0UNcywgCA4/UVaAaQMAQ4YvxzABorZgAZAiTylQjD9RKpZnNZwAEAJGeAIxPkhADsDMDeFbB3BeJdgXhXoN4VqHcF5l2BeVeQvCtIzhVQCN4A7hU4t2sC8gbwriB6VxC9K0D0BlBnAIreAOIMwOAN4N0qvCf9ZjPEG8DbaOptNDVnAPM2mnm3iuRttOTcKth7VcHeqwr2XlWw96qCwdloHNEbwNlojNEbwNtoBN4A3kbz3kpg9jYae7cK8TaaeLcK9TaaercKu95oRnnf1PT7tuYImZh3QPeb0IRfTKQUJqkYTVIpmkigYpikUpgAFsPESmESi9FkglXWREwmeC8yFRMuhQkXowkXo4mUMu+IFOMdLaafaDE91orRxIrRJMVimJTiHY0T/P2h7vHDMxE6wc65dPzFBgeO7Ow3SG3S2RP/7Udz93e+Wczvl/XupOTT2+qhd3By+++lPjhD+bJZP9SPb5u6PU25P0jZehMUZmDQkIF2mgNOMxBqb1vBQGwGGhrUBvk/",
+      "brillig_names": [
+        "_check_block_number"
+      ]
+    },
     {
       "name": "_check_timestamp",
       "is_unconstrained": true,
@@ -58,7 +138,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCHQCASoBKBS4IgEkAAS4IgEoAAiUAAABZJQAAAIQoAgABBIBLJwICBAA7DQABAAIoAIBDAgAEKACARAIABigAgEUCAAEoAIBGAgACKACARwIABSgAgEgCAAMmJQAAA1IeAgAEAR4CAAUACjgEBQYkAgAGAAAApSUAAAN7HgIABAknAgUAAQo4BAUGJAIABgAAAMElAAADjR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYLKAABgEUABCcCBQEBJAIABAAAAzsjAAAA9AsoAAGARgAHFgwCCCQCAAcAAAMpIwAAAQ0LKAABgEgACSQCAAkAAAMXIwAAASILKAABgEMACiQCAAoAAAMAIwAAATcLKAABgEcAChYMBgskAgAKAAAC6SMAAAFQCygAAYBEAAgkAgAIAAAC1yMAAAFlJwIBAkknAggCbicCCgJ2JwILAmEnAgwCbCcCDQJpJwIOAmQnAg8CICcCEAJvJwIRAnAnAhICZScCEwJyJwIUAnQtCAEVJwIWBBIAEAEWAScDFQQBACgVAhYtDBYXLQ4BFwAoFwIXLQ4IFwAoFwIXLQ4KFwAoFwIXLQ4LFwAoFwIXLQ4MFwAoFwIXLQ4NFwAoFwIXLQ4OFwAoFwIXLQ4PFwAoFwIXLQ4QFwAoFwIXLQ4RFwAoFwIXLQ4SFwAoFwIXLQ4TFwAoFwIXLQ4LFwAoFwIXLQ4UFwAoFwIXLQ4NFwAoFwIXLQ4QFwAoFwIXLQ4IFycCAQEAJwIIBAAKOAEFCiQCAAoAAALOJwILBBMtCAEMJwINBBMAEAENAS0MDA0qAwANBRPmMpnlFxQJACgNAg0AKBUCDicCDwQRLgQADoADLgQADYAELgQAD4AFJQAAA58nAg4EEQA4DQ4NLQ4IDQAoDQINPA0MCy0MAQYjAAAC4C0MCwYjAAAC4C0MBgIjAAAC9wQ4CwgBLQwBAiMAAAL3LQwCCSMAAAMOEjgGAgEtDAEJIwAAAw4tDAkHIwAAAyAtDAYHIwAAAyAtDAcEIwAAAzItDAgEIwAAAzItDAQDIwAAA0QtDAIDIwAAA0QkAgADAAADUSUAAAPlJigAgAQEeAANAAAAgASAAyQAgAMAAAN6KgEAAQX3ofOvpa3UyjwBAQImKgEAAQWeScksjTulvTwBAQImKgEAAQW6OL+KoDMf/zwBAQImAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAAPkLgGACIAGLgKABoAJAQCACAACgAgBAIAJAAKACSMAAAOzJioBAAEFdS4blGTo99s8AQECJg==",
-      "debug_symbols": "zVrbbuJADP2XPPNgz9hju7+yqiraphUSgorSlVZV/30nXRJSkqWFxNK8IAJ2zoWcyTCZ9+qxvn97vlttnrav1c2v92q9fVjuV9tNPnr/WFT3u9V6vXq+639cQfOCUT4bXl+Wm+b4db/c7asbRDNdVPXmMb8PgCmf5Gm1rqsbk4/FoJw00qGalEJXnMJIsbKEQ7GySr/4dlEhhVFCAUI4EuphjBNKCVtCSeA7QsAdoYADQj9xiKhPqGnjcFVbguvaeNy1rKdrY4rnXRMEO1RLLj/vmoXU/iAWlE9dE/gJIT7VIXxVm16HpnpVm8WxNhNp/bDj78Mw4l0KHA+1KST65vI0aMOlFsKp0abnySAA99nkngCjAhBiJxto2DRuFnSXASKE87pjdxETaFeKSp8AGCcDUEgtQAxfAEYu4Kitr0Ygveox5lHbaMRoveKxHAXT1sgIPcqjxVmU8FGg9X35Z8t034k634UGvhNNBmCEQy1HGQD8Zyi8BEC6DEiEAUCy6QqkBUgwBDCYDJBiF/k0AIiIvhZFnG6RSBsuhTgAiMkZgMUZIAVvAG8F4q1AvBWotwL1VmDeCsxZAUHwBvBWgN4K0FtB8FYQnIdriugN4K2AvBWQtwIGbwDyBnCetlCK3gDqDOB90yfvmz6pd9DUO2jmHTRjbwDnoDGQN4Bz0BijN4Bz0Nh7VsHeswr2nlVwdA4aE3gDeAeNvIcK9g4aew8V3ksJ7L2UwOIdNPEeKtQ7aOo9VKh30Mx7qLDpQVNq101Vvi5rjpBpTyvHRej80CszSRCLYVKMJ1iMJwGLYZJKYRKhGCZcChMqxpMZZlkzMZnhuchMTGaY9czFpBhPpBhPpJj7jhaTHStmPLFSxliBUjwRKMcTK4UJlpIdoRn+/lB3+uGeCJlh5Tx1/JMONhzpxU+QmqaLb/y3H/no93K3Wt6v68OGzKe3zUNvf+b+z0t9slXzZbd9qB/fdnWzafO4X7OZsaPQIkvIZLCJKmZkTNIcNrNoVM7fSkbNyH8B",
+      "debug_symbols": "zVrvbuIwDH+XfuaDHTuxvVc5TRPb2ISEYGLspNO0d790R6CjPTZoLeULasHu709jN6R5bx4X92/Pd8v10+a1ufn13qw2D/PdcrPOZ+8fs+Z+u1ytls933a8baD+Q5DPh9WW+bs9fd/PtrrlBNKNZs1g/5uMAiPkiT8vVorkx+Zj1wiMo7KPzoR6CUxgI1ohxH6yRoBt8O2uQwyChTEKOhEjOE2KDEs2G6RtCzFoIceIeoZ84RNYl1KbFcFVaguvS4rBrEdMhLZKed00oljsjJHjeNQtQgi0EPXVN4AeEGE51SLwqTa9DU70qzWgozaQMObPjIIow4F1is31sigjfDE/lcmHVFE+NNj1PBgFil03OyQNoUDcQHpK4nzRsFqRQkhDCed1kpdAYjiMGlT8BkEYDcCg3jil8ARgYwKRcbhiDdKKHmJOWO0ZkneChOgqmxUiCDuXB4CxK4lGgdX35Z8t4348NjoV7vjOPBsiDuPR/kh7Af1rhJQACfOhM0ANINl6BFIAEfQCD0QCJSgNPqQdAiL4WEY63SKQUlwL1ACg5A0RxBkjBG8BbgXgrEG8F6q1AvRWYtwJzVsAQvAG8FaC3AvRWELwVBOd2zYTeAN4K2FsBeyuI4A3A3gDO0xZO5A2gzgDeD332fuizeheaeheaeReaRW8A50KLwN4AzoUWkbwBnAstes8qovesInrPKiI5F1peTvQG8C409m4V0bvQoner8F5KiN5LCVG8C028W4V6F5p6twr1LjTzbhU2vtCUy7qpytdlzQEy5bJyXIRmapkkoGqYVOMJVuNJwGqYpFqYEFTDJNbChKvxZIJZ1kRMJngvMhGTCWY9UzGpxhOpxhOp5rmj1dSOVdNPrJYeK1CLJwL1eGK1MMFaakd4gr8/fLh8f0+ETLByng78k/Y2HOnFb5DapIsf/Lcf+ez3fLuc368W+w2ZT2/rh87+zN2fl8XJVs2X7eZh8fi2XbSbNo/7NdsZOwrPsoRMBttSxYyMSdrTdhaNGvOvklEz8l8=",
       "brillig_names": [
         "_check_timestamp"
       ]
@@ -133,70 +213,12 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "public_dispatch"
       ]
     },
-    {
-      "name": "_check_block_number",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "internal",
-        "view"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "operation",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 8
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "value",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "1433889167918961673": {
-            "error_kind": "fmtstring",
-            "length": 17,
-            "item_types": []
-          },
-          "2242946026394210301": {
-            "error_kind": "string",
-            "string": "Block number mismatch."
-          },
-          "8209322232883590150": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called internally"
-          },
-          "10421965853029650238": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called statically"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCLgiASQABLgiASgACJQAAAFIlAAAAfSgCAAEEgEsnAgIEADsNAAEAAigAgEMCAAQoAIBEAgAGKACARQIAASgAgEYCAAIoAIBHAgAFKACASAIAAyYlAAADQR4CAAQBHgIABQAKOAQFBiQCAAYAAACeJQAAA2oeAgAECScCBQABCjgEBQYkAgAGAAAAuiUAAAN8HgIABAUKOAQCBQw4BAIGCygAAYBFAAInAgQBASQCAAIAAAMqIwAAAOMLKAABgEYABxYMBQgkAgAHAAADGCMAAAD8CygAAYBIAAkkAgAJAAADBiMAAAERCygAAYBDAAokAgAKAAAC7yMAAAEmCygAAYBHAAoWDAYLJAIACgAAAtgjAAABPwsoAAGARAAIJAIACAAAAsYjAAABVCcCAQJJJwIIAm4nAgoCdicCCwJhJwIMAmwnAg0CaScCDgJkJwIPAiAnAhACbycCEQJwJwISAmUnAhMCcicCFAJ0LQgBFScCFgQSABABFgEnAxUEAQAoFQIWLQwWFy0OARcAKBcCFy0OCBcAKBcCFy0OChcAKBcCFy0OCxcAKBcCFy0ODBcAKBcCFy0ODRcAKBcCFy0ODhcAKBcCFy0ODxcAKBcCFy0OEBcAKBcCFy0OERcAKBcCFy0OEhcAKBcCFy0OExcAKBcCFy0OCxcAKBcCFy0OFBcAKBcCFy0ODRcAKBcCFy0OEBcAKBcCFy0OCBcnAgEBACcCCAQACjgBBAokAgAKAAACvScCCwQTLQgBDCcCDQQTABABDQEtDAwNKgMADQUT5jKZ5RcUCQAoDQINACgVAg4nAg8EES4EAA6AAy4EAA2ABC4EAA+ABSUAAAOOJwIOBBEAOA0ODS0OCA0AKA0CDTwNDAstDAEGIwAAAs8tDAsGIwAAAs8tDAYFIwAAAuYEOAsIAS0MAQUjAAAC5i0MBQkjAAAC/RI4BgUBLQwBCSMAAAL9LQwJByMAAAMPLQwGByMAAAMPLQwHAiMAAAMhLQwIAiMAAAMhLQwCAyMAAAMzLQwFAyMAAAMzJAIAAwAAA0AlAAAD1CYoAIAEBHgADQAAAIAEgAMkAIADAAADaSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFce1fE3G+NAY8AQECJioBAAEFkKJCubMVTz48AQECJgEAgAOABYAHLgCAA4AILgCABIAJCwCACIAHgAokAIAKAAAD0y4BgAiABi4CgAaACQEAgAgAAoAIAQCACQACgAkjAAADoiYqAQABBR8gi4cBmc/9PAEBAiY=",
-      "debug_symbols": "zVrbTuMwEP2XPOfBY3tu/MoKoQIBVapaVMpKK8S/rwN1GpK00DYj+QU1aKbnzLHP2HX8Xj0292/Pd8v10+a1uvnzXq02D4vdcrNOT+8fdXW/Xa5Wy+e7/r8r1/6B4D4TXl8W6/b5dbfY7qobAFWpq2b9mD57B5S+5Gm5aqob5Y96FB4lxH10lOi7YPITwYLs98GCwv3g2zoRwklC3nl/INTDmCZEBJkQsfuJkMOOkIchofgbhWLsE/pMw4vSMFyWJtOqpXq6NIzhtGoMTvfRnMJPq6ae8oCoFxyqRuE3hHBYB8lFaXwZmsBlaTSZRoFzFuFhXqObUI+c5DlHTvWHCSohD74I6lBqna6CvHZ0WE7TCd3siu4QChK/AOhqgOgpAwT/DWBiZgXJ3USj4170FPMgmUUI2guemuBeJQ9scM6fDgZwnMcofda+Lq0sqS1eL0vsdOc41N17vhoAwe1jMfAI4EivPQeAXR4rDm4EgP76Cjh2RhkDHDH+OQAUQgagMYBGW4mCu14i5mwucWEEAGoMcGSBnBEAjQHQugK0roCsKyDrCti6ArauQKwrEOsK1LoCNa4gOmcNYF6BcbuOEK0BrCvw1hV46wpCsAZgY4DorQHIGADBGsC6VVgv+pGsjUbWRmNro7EYA4i10cS6Vai10dS4VaD1rgKtdxVovatA610FgrHR0AdrAGOjYfDWANZGi2ANYG0066MERGujoXWrIGujkXWrYGujsXWrkOuNJjGfmwp/P9acIJNfFfHhEDq9jfpkQqUw0WI00VI0IReLYaKlMIFQDBMphYkvRpMZdlkzMZnhvchcTLAUJliMJliMJlTKukNUjHe4mH7CxfRYKUYTKUYT9cUwKcU77Gf4+RO7rx/fieAZTs6p458m0xBAzn6D1CadvfDffqSnv4vtcnG/avY3JZ/e1g+9i5O7fy/N4A7ly3bz0Dy+bZv2NuXhImXrTWCoQSCRgXaZA9QaKLaPrWBAUgO7hJqQ/wM=",
-      "brillig_names": [
-        "_check_block_number"
-      ]
-    },
     {
       "name": "check_block_number",
       "is_unconstrained": false,
@@ -1787,12 +1809,12 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZfbisIwEIbfJde96ExmcvBVFpGqVQqlStWFRXz3TcQYD6lS1j1Bb0om/acz+WbapHsxL6e75aRqFquNGL3tRb2aFdtq1ThrL4COc5t10Xhzsy3arRghk85E2czdUAEeMrGo6lKMrD5k92KkPIhRRbEyCbHMLZ/EErzikRjYMp3UbnwhRwOpTABVyASIo9omny6VDA8nyK/U40wAD2Q6yKiBTAcZnSRDBiIZ+ZgMAYT0CThGUHAMYL47gE0FAGnisi+Qevd7sdIcOsGNTQzBlKqukhiqqwGeVhd0rK7Mn1QXFJuYiv5adTEf2HSygYFNJxsc2HSykX+dze/tJkgDm042/Ao2Nj+zMVI/YaND15OMZIDyYzrqBekYiqUylh6nA5bt+TW0CvhyI0/BJ76gb/hm30f93xdgfn4BGs/9Y42WjxdgORxiATBm4jI8jJ01bau6rpaTq7+z3F8o2eosw5GPtbptR1L9XXR/F9PfxfZ0cRYc/1OTjqTD50oh3SB15nvRVsW0Lj1Lf3fXzAJaZ24/1uFOgL9uV7NyvmtLX4ZYAb9HuQ8joT8g+0MgQ8Yq5uanEDJ0UwcX+RM=",
+      "debug_symbols": "7ZfdbvIwDIbvJcc9qB3bSbiVT9NUoJsqVQUV+KQJce9LEGkYS0Fo/1JPUJy+rp3HJkn3alnPd8+PTfe02qjZv71qV4tq26w6b+0V0HFus666YG62Vb9VM2Qyhaq7pR8K4KFQT01bq5kzh+K9GKmMYpQkFpsR69LxSawhKK6JgR3jSe3HIoMcLeQyAZSYCRAntcu+XYuOLyco36gfCgU8kRkhIxOZETImS4YsJDL6OhkCoJOYgFMEgWMA+9UBXC4AaJuWfVaB4P5eLIZjJ/ixTSGYctUVHeulDcDN6gKn6qK9UV0QtikV87HqYjmxGWUDE5tRNjixGWWjfzubnztNkCY2o2z4M9i4cmBjtbnBxsSuJ53IAJXHdOQT0rGUSmUdXU8HHLvhb+gE+Pwgz8EnPqNv+eLcR/PXF2C/fwEGh/5x1ujrC3A8bLJwtsf6DA8P3pr3Tds2z49vvs7K8EPZVmcdr3xs5LIdSe53Mfe72Ptd3J0u3oLjd2rWkUzcgATpAqk3/1d9U83bOrAMT3fdIqL15vZlHZ9E+Ot+taiXu74OZUgVCGeU3xgJwwU5XAIZCpaUW5hCKNBPHXzkVw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "check_timestamp",
@@ -3386,34 +3408,12 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZfbisIwEIbfJde96ExmcvBVlkWqVimUKlUXFvHdNxFjPKSVInuC3pROOtP5+f6kSQ9iUc72q2nVLNdbMXk7iHo9L3bVunHRQQCfxrabovHhdle0OzFBJp2Jslm4WwV4zMSyqksxsfqYPSYj5SEZVUxWJpEsc8vnZAk+oy8Z2DKds939VToaSCkBVEEJEMdsm3y7VDK8nCC/yX7PBKiRTAcZPZLpIGOSZMhAJCP7yRBAkE/AsYOCUwP7zQ0wTzXQMrhlrpz1xY+ElOYwD9y9iQ2YUt4qicFbDfDUW9DRW5k/8RYUmyhFv+YtwkimgwyOZDrIyJFMBxn622R+bw9BHsl0kFGvk7H5hYyR+gkZHeY7ycgFKD+J0S+LMRRtMpb6xYBle1l+VgFfb9wp8MRX5A3f7/Pmf8u3Py1f42XmWKNlv3zL4cAKgHGNgHTz2EWztqrrajW9+RPL/YWSi59lON6xVvcTkdTwEj28xAwvsQNLXASnf9JkIenwmVJId0hd+FG0VTGrS8/SP90384DWhbvPTXgS4G/a9bxc7NvS2xAd8Du2+yAS+tO2PwwzZKyiNj+EkKEbOrrOXw==",
+      "debug_symbols": "7ZfdivIwEIbvJcc96ExmJom38vGxVO0uhVKl6sIi3vsmYhrXTRWR/YOelE76Tmd43jRJ92pZz3cvT033vNqo2b+9aleLatusOh/tFfBxbLOuuhButlW/VTNkMoWqu6W/FcBDoZ6btlYzZw7FZzFSGcUoSSw2I9al45NYQ1BcEwM7xpPa34sMcrSQ6wRQYidAnNQu+3YtOr6coPyg/l8okInMCBkzkRkhY7NkyEIio6+TIQA6iQk4VRA4FnBfXADLXAGjo1v2zNmQ/JmQGI7zwN/bVIAp563o6JY2ADe9BU7eor3hLQjb1Ip5zFuEicwIGZzIjJDRE5kRMvS7yfzcHoI8kRkhI4+TceVAxmpzg4yJ85104gJUHpsxDzdjKdlkHV1vBhy74fNzAny+cefAE5+Rt3y5z9u/3b777vYNDjPHWaOvt+94WFjhbF0F7eexj+Z907bNy9OHP7EyXCj78bOOxzs2cjkRSe5PMfen2PtT3J0pPoLjP2k2kUxceATpAqkPX6u+qeZtHViGp7tuEdH6cPu2jk8i/HW/WtTLXV8HG5IDYcf2CyJhOG2HwzBDwZJ6C0MIBfqhg6/8Dg==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLLqoMwEIbfZdYucr/4KuVQosYSCFGiHijiuzeWWKSWduNmmAkfw5fkn6Gx1XS7utB2A5SXGXxXm9F1IU3zUkAVnffudt0fA1oLpk9+6E1Yx2E0cYQSI4ZVATY0z17KtKN13kKpU3vApRIZVoi9UME+oJzwjHKOXiimevkrALMTZBSVmwzX32UY1RllQh1k+Bkyim0yWn2XEWh7GUHEQUacIKMJybCm/IeMQhmV6O2bljT+m+hM5W2OVzuFepe28d7bt+D1sattM0W7RnCXvlQv6QqEprVp9QM=",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "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"
     }
   ],
   "outputs": {
@@ -3444,12 +3444,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::check_timestamp_parameters"
+                "path": "Router::_check_timestamp_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::check_timestamp_abi"
+          "path": "Router::_check_timestamp_abi"
         },
         {
           "fields": [
@@ -3504,12 +3504,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::_check_timestamp_parameters"
+                "path": "Router::check_timestamp_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::_check_timestamp_abi"
+          "path": "Router::check_timestamp_abi"
         },
         {
           "fields": [
@@ -3570,7 +3570,7 @@
     },
     "281": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "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"
+      "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"
     },
     "298": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
@@ -3602,7 +3602,7 @@
     },
     "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "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"
+      "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"
     },
     "64": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
@@ -3618,7 +3618,7 @@
     },
     "97": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "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"
+      "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"
     }
   }
 }