@aztec/protocol-contracts 0.66.0 → 0.67.1

package/artifacts/Router.json

@@ -1,18 +1,20 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
+  "noir_version": "1.0.0-beta.0+b3f4ad661c8c6f88544d714fd5b7b6f58a8ce4ad-x8664",
   "name": "Router",
   "functions": [
     {
-      "name": "_check_timestamp",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal",
-        "view"
+        "public"
       ],
       "abi": {
         "error_types": {
+          "10421965853029650238": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called statically"
+          },
           "11405868724477732285": {
             "error_kind": "string",
             "string": "Function _check_timestamp can only be called internally"
@@ -26,10 +28,31 @@
             "item_types": [],
             "length": 17
           },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
+          "2242946026394210301": {
+            "error_kind": "string",
+            "string": "Block number mismatch."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8209322232883590150": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called internally"
+          },
           "8443716675528357851": {
             "error_kind": "string",
             "string": "Timestamp mismatch."
@@ -37,30 +60,19 @@
         },
         "parameters": [
           {
-            "name": "operation",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 8
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "value",
+            "name": "selector",
             "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 64
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgMEAiYCBAQAHxgABAADgEMdAIBDgEMCHQCARIBEBS0IgEMAAS0IgEQAAiQAAABUJwIAAQSARSYCAgQAOg0AAQACJAAAAy4eAgAEAR4CAAUACjgEBQYjAgAGAAAAdSQAAANXHgIABAkmAgUAAQo4BAUGIwIABgAAAJEkAAADaR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYmAgQCAQo4AQQFJgIEAQEjAgAFAAADFyIAAADGJgIHAgIKOAEHCBYMAgcjAgAIAAADBSIAAADhJgIJAgMKOAEJCiMCAAoAAALzIgAAAPgmAgoCBAo4AQoLIwIACwAAAtwiAAABDyYCCgIFCjgBCgsWDAYKIwIACwAAAsUiAAABKiYCBwIGCjgBBwsjAgALAAACsyIAAAFBJgIBAmUmAgcCICYCCgJsJgILAm4mAgwCdCYCDQJwJgIOAmQmAg8CSSYCEAJhJgIRAnImAhICbyYCEwJpJgIUAnYsCAEVJgIWBBIAEAEWASYDFQQBACgVAhYsDBYXLA4PFwAoFwIXLA4LFwAoFwIXLA4UFwAoFwIXLA4QFwAoFwIXLA4KFwAoFwIXLA4TFwAoFwIXLA4OFwAoFwIXLA4HFwAoFwIXLA4SFwAoFwIXLA4NFwAoFwIXLA4BFwAoFwIXLA4RFwAoFwIXLA4QFwAoFwIXLA4MFwAoFwIXLA4TFwAoFwIXLA4SFwAoFwIXLA4LFyYCAQQAJgIHAQAKOAcECiMCAAoAAAKqJgILBBMsCAEMJgINBBMAEAENASwMDA0pAwANBRPmMpnlFxQJACgNAg0AKBUCDiYCDwQRLQQADoADLQQADYAELQQAD4AFJAAAA3smAg4EEQA4DQ4NLA4BDQAoDQINOw0MCywMBwYiAAACvCwMCgYiAAACvCwMBgIiAAAC0wQ4CgcBLAwBAiIAAALTLAwCCSIAAALqEjgGAgEsDAEJIgAAAuosDAkIIgAAAvwsDAYIIgAAAvwsDAgFIgAAAw4sDAcFIgAAAw4sDAUDIgAAAyAsDAIDIgAAAyAjAgADAAADLSQAAAPBJScAgAQEeAANAAAAgASAAyMAgAMAAANWKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQWeScksjTulvTsBAQIlKQEAAQW6OL+KoDMf/zsBAQIlAQCAA4AFgActAIADgAgtAIAEgAkLAIAIgAeACiMAgAoAAAPALQGACIAGLQKABoAJAQCACAACgAgBAIAJAAKACSIAAAOPJSkBAAEFdS4blGTo99s7AQECJS0AGMoYyg==",
-      "debug_symbols": "zVrdTiIxFH6XuebitOev9VU2xqCiISFgEDfZGN99Z1hmQGcWIvZLemMsOZ3vZ/qV0va9eVzcvz3fLddPm9fm5td7s9o8zHfLzbptvX/MmvvtcrVaPt+dftxQ9yflff3ry3zdNV938+2uuQmWadYs1o/tv07UPuFpuVo0N6zxYzaqFlU+VItaGKqzTBSnSPFQnGLw0+LbWZOlAB1OqafD2S/QCaw9naDhK51vu9N2CiTX9Arxql7+c8PMJRyqzfWSYSkP7y8H/WJYiFepiH5NL74KS+iqXjrVK1s+dMrJLrisOfYjTTPbBZeVpXdZu8d9dlnpApuTYd8r0EkFgWKf3UA87mXTbpHK0KsTcFY55yGPlIbaltA/BP05gkQbEh8/IUyMdqWejikfEx/yFPU4vDSOzMfiNFEc01Ack9j54kTaD7hEzqc0Ole8gO8ig+8uI99d0Qg5/RxBQ++SnozOA0IkhiMU0ODUFzvTCCEWeA/qfbHRGIEJjSAFXDLuJyKzMYIyGsED+k27oRFSCQ1uw7zEI4QSmT6LwCUyfR4hBjiCoREYroHhGgSuQeAaFK5B4RoMrsHgGhyuweEa4LM3J7iGTHAEBSMIERwBriHANQSBI6DXGhIZjuBohP/sgpREQM8aAl8JiMATp/DEKTxxmtEIBk+cwWcNhyfO4bMGfK0h8LWGwNcagl9rZHTilASOgE6cBoYjoBOnMcIR0IlT+K6DMjpxKgRHgCdO4LOGwhOn8FnDCiQuSb9nnPzzfusEm/5g1I/nCO2R8p6KV0PF63HF63ElaTVUSixrSlGReqjkWqgYVeOKlVh6FaJS4lSlFBWrhgrX4wrX44pU8x1kUk+CtJ55ReuZba0eV6weV5zroVJNgpxK/C6S4fnjWyJeYrfdBgWWRvfh0vdPn/a9vv0Sbj/a5u/5djm/Xy0O94Sf3tYPJ9eGd39eFl9uEL9sNw+Lx7ftortLfLxG3I3G0MoKKd52N2C7ptEsmHbNsG/mWfDQorbIfwE=",
+      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAAT4KAIAAgBYryrgCjgBAgMmAgQEACYCBgQDADgEBgUsCAECABABBQEmAwIEAQAoAgIFLA4EBQAoBQIFLA4EBSYCBQQDADgCBQQmAgQEAiYCBQEBJgIGBAEmAgcAASYCCAQAIwIAAwAAALIiAAACKiwIAQMmAgkEAwAQAQkBJgMDBAEAKAMCCR88AAYABAAJLA0DCQAoCQIJLA4JAywNAwkAKAkCCSwOCQMsDQMJACgJAgksDgkDLAgBCQAAAQIBLA4DCSwIAQMAAAECASwOCAMmAgsEDCwIAAwsDAkNLAwDDgAQAAsAJAAABSEsBAAALAwNCgAoCgIMADgMCA0sDQ0LHAwLDAIcDAwKABwMCgsCJgIMBA0sCAANLAwJDiwMAw8AEAAMACQAAAUhLAQAACwMDgoAKAoCCQA4CQgMLA0MAxwMAwoFHAwKCQAeAgADAR4CAAoACjgDCgwjAgAMAAABqiQAAAWcHgIAAwkKOAMHCiMCAAoAAAHBJAAABa4eAgADBhwMAwoAJgIMBA0sCAANLAwKDiwMCw8sDAkQABAADAAkAAAFwCwEAAAsDA4DIwIAAwAAAf8kAAAISiwNAgMAKAMCAywOAwIAKAICCiwNCgkmAgsEAgA4CgsDOg0AAwAJIgAAAiooAgADAHntFoEKOAEDCSMCAAkAAAJFIgAAA6EsCAEBJgIDBAMAEAEDASYDAQQBACgBAgMfPAAGAAQAAywNAQMAKAMCAywOAwEsDQEDACgDAgMsDgMBLA0BAwAoAwIDLA4DASwIAQMAAAECASwOAQMsCAEBAAABAgEsDggBJgIGBAksCAAJLAwDCiwMAQsAEAAGACQAAAUhLAQAACwMCgQAKAQCCQA4CQgKLA0KBhwMBgkCHAwJBAAcDAQGAiYCCQQKLAgACiwMAwssDAEMABAACQAkAAAFISwEAAAsDAsEACgEAgMAOAMICSwNCQEeAgADAR4CAAQACjgDBAkjAgAJAAADMyQAAAhcHgIAAwkKOAMHBCMCAAQAAANKJAAACG4eAgADBSYCBwQJLAgACSwMAwosDAYLLAwBDAAQAAcAJAAABcAsBAAALAwKBCMCAAQAAAODJAAACIAAKAICBCwNBAMmAgYEAgA4BAYBOg0AAQADIgAAA6EmAgECciYCAgJsJgIDAiAmAgQCayYCBgJ0JgIHAmUmAgkCdyYCCgJuJgILAmMmAgwCcyYCDQJvJgIOAlUsCAEPJgIQBBEAEAEQASYDDwQBACgPAhAsDBARLA4OEQAoEQIRLA4KEQAoEQIRLA4EEQAoEQIRLA4KEQAoEQIRLA4NEQAoEQIRLA4JEQAoEQIRLA4KEQAoEQIRLA4DEQAoEQIRLA4MEQAoEQIRLA4HEQAoEQIRLA4CEQAoEQIRLA4HEQAoEQIRLA4LEQAoEQIRLA4GEQAoEQIRLA4NEQAoEQIRLA4BESYCAQEACjgBBQIjAgACAAAE9yYCAwQSLAgBBCYCBgQSABABBgEsDAQGKQMABgXlj5hZBzFikAAoBgIGACgPAgcmAgkEEC0EAAeAAy0EAAaABC0EAAmABSQAAAiSJgIHBBAAOAYHBiwOCAYAKAYCBjsNBAMlJwCABAR4AA0AAACABIADIwCAAwAABSApAQABBfeh86+lrdTKOwEBAiUkAAAE+CwNAQMsDQIEJgIGBAIMOAQGByMCAAcAAAVFJAAACNgAKAMCBgA4BgQHLA0HBSwIAQYmAgcEAgAQAQcBJgMGBAEAKAYCBywMBwgsDgUIJgIFBAEAOAQFBw44BAcIIwIACAAABY8kAAAI6iwOAwEsDgcCLAwGASUpAQABBZ5JySyNO6W9OwEBAiUpAQABBbo4v4qgMx//OwEBAiUkAAAE+Ao4AQMFDDgBAwYmAgECAQo4AgEDIwIAAwAACDwiAAAF5iYCAwICCjgCAwcWDAUDIwIABwAACCoiAAAGASYCCAIDCjgCCAkjAgAJAAAIGCIAAAYYJgIJAgQKOAIJCiMCAAoAAAgBIgAABi8mAgkCBQo4AgkKFgwGCSMCAAoAAAfqIgAABkomAgYCBgo4AgYKIwIACgAAB9giAAAGYSYCAgJJJgIGAnImAgkCbyYCCgJpJgILAnYmAgwCZSYCDQIgJgIOAmwmAg8CbiYCEAJ0JgIRAnAmAhICZCYCEwJhLAgBFCYCFQQSABABFQEmAxQEAQAoFAIVLAwVFiwOAhYAKBYCFiwODxYAKBYCFiwOCxYAKBYCFiwOExYAKBYCFiwODhYAKBYCFiwOChYAKBYCFiwOEhYAKBYCFiwODRYAKBYCFiwOCRYAKBYCFiwOERYAKBYCFiwODBYAKBYCFiwOBhYAKBYCFiwOExYAKBYCFiwOEBYAKBYCFiwOChYAKBYCFiwOCRYAKBYCFiwODxYmAgIBASYCBgEAJgIJBAAKOAYCCiMCAAoAAAfPJgILBBMsCAEMJgINBBMAEAENASwMDA0pAwANBRPmMpnlFxQJACgNAg0AKBQCDiYCDwQRLQQADoADLQQADYAELQQAD4AFJAAACJImAg4EEQA4DQ4NLA4JDQAoDQINOw0MCywMBgMiAAAH4SwMCQMiAAAH4SwMAwUiAAAH+AQ4CQMCLAwCBSIAAAf4LAwFCCIAAAgPEjgGBQIsDAIIIgAACA8sDAgHIgAACCEsDAYHIgAACCEsDAcBIgAACDMsDAMBIgAACDMsDAEEIgAACEUsDAUEIgAACEUsDAQBJSkBAAEFdS4blGTo99s7AQECJSkBAAEFce1fE3G+NAY7AQECJSkBAAEFkKJCubMVTz47AQECJSkBAAEFHyCLhwGZz/07AQECJQEAgAOABYAHLQCAA4AILQCABIAJCwCACIAHgAojAIAKAAAI1y0BgAiABi0CgAaACQEAgAgAAoAIAQCACQACgAkiAAAIpiUpAQABBeidCf6hES0OOwEBAiUpAQABBUWnynEZQeQVOwEBAiUtABjKGMo=",
+      "debug_symbols": "zV3bTuQ4EP2XfubBt7p4fmW1GjEzzAgJwQiYlVaIf980kNAQ01ZOcth+QXTL55yyq1xJXHb6Yffj4tufX18vr3/e3O2+/PWwu7r5fn5/eXM9fHp4PNt9u728urr89fXw613Y/9H61P7u9/n1/uPd/fnt/e5Llny2u7j+MfynccD/vLy6ePr28e+znfliiOflkOUqdblKXa4SQwIwthwTAZ0I6KQIYHQ5JgcAI8sxS+PzbNY2hlDH1jHEXKb2Kk8SnvgSRpeo/F5Uei9SoPcixeWRm2IBMMuTcUp5bfc92Etbzza1TSU+8xuXPycy//JMlQrg7yIABvC3ZACz/CqXNAEYYKwtAhhZHTOxTjFTZjHjgcxfyPzO5V9/4ejwG5U/h0TmVy5/DLycOW9bPb20rfWVN9UXW+R0bEknNC6p/F+22NyWejq25BMal1y587QUMj83z2ch50kh50mNZH6y/RbI/J86F4en5jI+ZXnOs9lo9ZSs8ZMamw3u6FBrSphZU/NJWbN+vUdrGBUshE7rIhN1kQPuYbGg0dFhfWLsaYr2+HZloYT8ybYPkTTanqt1bB+W30bbo8SZ7dRx3yvEzFZIka6gn+thtRJfWqtJz8Nep+isUd57ONNHJytbYf09WFdh9XWr6niVrq6dtlLTOCmlZu34V/KYOl0kvfevlA0tP8gm48jI6pGJQabcH2qZKWihKzhbwRJdQdkK61fMugrCVqj0PlR6tFZ2tEpgx5LE5SvCEpevvksKAGYDD5YQp+4PtwfvkrKkSpfImS/hdInC78XSC+Qeo8sLNOLrb7Q6NUzZIn92JLZIoD0Jei80BL4EvxdxeRQqsHlEUwIw65fNjpV8NQcyv5D5l5eFtQD+LsvLwiqAv2V5WVg1AhgBMMBYWwEw3KV69Uzm55ZktUYyP3fLgIVA5mfbzy2FWfzUJeOjpVmLfjq2pBMaF+ZWr4WlWWNuC1tsywmNS+GWZK1w87xJJPOT86SQ8+T6Bc0OP9l+y2T+T52Lw7fjZExDrWg2Gz2dlDUnNTaVWjyilmWtfnLRbsOyrAd20c4Du2jnsdAV6ud6eMOyrCf66KTKVlh/T9VTWH+nFDWNl6KopXZai+lUmDWrHQ8PdcXRw8Xrew+XDUYnTSvbavPRkURXULaCBrpCoSs4W8EyXYHeB6dHq9OjtdJjqdIrhzUUvgS9clhj5kvwe5GWL13XpbvvnzCATgF0gNNwFSjQVgF0FNABSgsVKC1UA3Qc0HFABzmSD53JDxkBIUoRUULO5QfkYH5ATuYH5Gh+QM7mByCZDMmvICDEuYI4VxDnKvIWCUWca0gYGeJcR8LIEec6EkYVcS6SjaBXhGDvCAE2yw0YIIwisF1uAAkCApwbgTubAYQ4F9hqMYAQ5woSRuufu21cfLLXdSpJz+zrj9QdZafavv6421H2ymRfv7/jKLsz2SvV9vUvCzjCntYftT/KLkz2RLU9UW3PkcpOjZmSqezMubr49TIL2am2a6KyM2Mmt9eLZNoLIn5wKPi5Fh5ze/NtD9S8xmociyl6cKhsArWnYw+EKLWf9XqgCoAEURJEqX0kQOpYAtJgDZABoPZZsh4IUXJEyRGl9kaCHqh5dVLREWRpBirtTZw9EKIUEaV2juiA2hsMeyADQB9szZn8VIJPoOFW/xnUDqNhtXsE5fQG1KisS5giQfJrDo610XhImWORNqeD9yxEb+1w8alxGgq2xxt7kDEHeLB8aMZzR5ujU8o0Olbmo9N+0dZxkLRjS6YUJQdbe15BAoDaN5gWxuN9lsMc1L73EivTdG6A2sX8DqhdH9Y8XrFVWyABQO2ns85AtB+6OqD2s5SZTrGXZyBtR0QPJAAoI+a1V2E6oIIoFURJECVBlBRRUkTJECVDlBxRckQJmhoVULL28m4PZAAoIkoRUUqIUvtZogPKAQEJAqoAqP0A0gMhYYQkFhPEuYo4VxHntotNPRDiXEfCyBHnOhJGSDYyJBs5ko0cyUYeIwICwshTQECCgADnei4ICHEucpvzwfbRDkiQMBLEuYqEkSLONSSM2mWiwRMjyN7ely9a6PN2mWgrdqfa7lTbK9P22s6Sm7Ebk72ddzdjVyZ7otreTvlbsbcz9lbs7dS+GTvVdqHaLsw8U5UaM0aNd6POVafa7lTb2y8f2oydGDPpgz2bVibIfM0xhQ9qXpPOsIjyFvQ4fPzn/Pby/NvVxd3u6XfBfv65/n7wM2H3//6+ePeLYb9vb75f/Phze7H/7bDXnw3bT/8y2Fck7cdnP/ZJw1lS2X/ch1EZigVFfFAdlP8D",
       "brillig_names": [
-        "_check_timestamp"
+        "public_dispatch"
       ]
     },
     {
@@ -423,7 +435,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::header::Header"
+                    "path": "aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -1531,7 +1543,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "aztec::protocol_types::header::Header"
+                  "path": "aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -1643,13 +1655,183 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZXdisIwEIXfJde5mMnkZ+KrLItUrVIordS6sIjvvok0bXUDsu4PLHgjmfabntOTMT2JTbk67pZVs20PYvFyEnW7LvqqbUJ1Eqgv1w77oonloS+6XizQepCibDZh6QDOUmyruhQLMuosP9GKiQdasZ1o1DmaDPqBJuPVHdoDu4H2CDjSSkGGRseUfDNMz1Y2B4OyCQZn5vCrFGieweSDsc9g8sG47wdD3qmB1gA80p4uCvzrCj6rQM4kBW3vKSAAjTjAjPe5UA0n9xanSBE5+lHwI37cGBDgTCTrB9mN4xbWZOcRZUYZvUlDEdZsbhJV+O/fQP39G3iiNKXBHdKVpVCsuqquq93y6lsG8Ufn3QbR9DxUfDtmmh5p0o80mUea7JebQoWRzf+Bwik6dDrjp8ZwQr6eQ/lWdFWxqsuYarx7bNYp5FD27/t0J23DvmvX5ebYlXFDpr2IqRJIDfFkiUY0S0Ojt8slRVJxUA3KHw==",
+      "debug_symbols": "7ZXRasIwFIbfJde9OCc5SU58lTGkapVCaaXWwRDffYlrGnUBmdsYgjelp/1O/j9/0vQgVtViv5nX7brbidnLQTTdshzqrvXVQSCdnu22ZRvK3VD2g5ihcVCIql35WwtwLMS6bioxU1odiy+0ZMUjLdkkGq3O0EqjG2mlnbxBs7N6pNmxS04QMzRaVtE3QxpbmhwM0kQYgniCXwuB+hlMPhjzDCYfjP15MAQ6midwONHmU4H/XMFlFdQUKZK5pYAAasIBznjjMrjm6N5gipRlsCPhV+zYKR/AM42sHXRINuIODZ0nlNnJUjHFrSwJ1VWgEh9+BvIfZmDNhDtHl7vUF4u+bpp6M7/4lUG4UN6tF43joeSrXUbqjh66o0ff0WO+2+MLDGj+2/Hn59hodTob2fo+X72VfV0umirkGV7u22WM15fD+za+iQuw7btltdr3VViKtAohUAUFQThSgg/iQqvJ2umRVIVkr+qVPwA=",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal"
       ],
-      "verification_key": "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",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-7910244512f567b2c80618688fdf51d9-mega-honk-true"
+      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAAABAEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAACwUoGrQSeSMwPr+aGXrBju2NC0wnTt+dAi0eUyqVvzmBzmo4wcRFGPMqaJv1BEJ5rmfsgEHopSAHm93ELJR3iQQGZrenAj6JLT0J+IMDQHzfvcPAEINnYItLX7xQSPdHRv3Nol9tnLEu6OdnFnbV40I/sLtDulWXVq1jJNLUfvuKUby1CyY5WuHpY9qmP5MGZYG9CJoeOHJE/kT/QODa7gA8TsYZIGodFBmXc3aH/FGZOnDTcGv2zQjF+H8JeBUfBSCYybnZeMPuSV21vor+nwqq846Pv8Dasg52DvjZKh3KnXGIYQt6RGINjhkIE5/3kkkwuzgR7pf/VJ9Gvglef4Ej1qDuNjY/kKhb6J2L1tqEdg8rfdQo71nnlh79S8jPiO4QBtQ33d38EGU1sj9bb3IePviXlE5IvqW7lnJEXM6MCrC9vkV84evbT5yIRT6j39Efp7cKUd1712vr1HZ1doDcNiGH9xQNgRcF6QukMMdtFncVoZ0URled7q9d4ZlISqHEK2Ho8Be1crPjUEI0RcDAhlQKym3fWCHWE9j4fULFkcUI7/Z7Gm2oKkCJbDBGMqfNvl0/qkF4/N+keqIqvUqBRBmjjBFHUJCXO1yIWHaCZcY5kVLBdJXKrwFD7kEHS1Fyhz4YjMW5xiM51vQDUFe0uH9OsXLG0voXNxF1IrYAmJximA41FWMDE7ngCYlh6s4d9ovu69nKidMaRjzYewYDVbQhRbOwLjxImrx4kJxHo3fyB+FPJUaA4c4Lr3CSiXWtK3k5KYmr2nG96+KvtqVnesWzPD52R8OFQ3lfxngJqVhFdIr9PqFdktPx0H6QDoVaeqm6cNi44NQemPo70wdWofvthy4uxUKRzAmRGoSdEeIpmW+UOcDuoGZDa0H8BE/AU2l8u2I1ov813hiHhk1yiRDRNOexGC0eHHn/hIcDc26b0le3IQluluJg6ccVVwwIRFhX+PO9fvoPLNE1sYHb01M9duFmNGrtP+vz3zhMiQUWZlrb8qqrAQCwJshuB+gcG4IdBBgcLglyGEs6RXgKxSIZ0Jo0pgXarcDHX+sGI1P007k9HwLIOiO1OIHxSldnKkHdUadvk2orISVo50ngi/3u5SDsp35d4XuX53STwoM84ypMWvkAMdDu7s77AHWqxqveUTCvgSupAYNcUaNR9MftIDiwZLdtmc+XL6oCnXIQVvgxvRmZoRLufS8dNsoxidd0b0nzpCPBTLpOsob9MxwKJ2XQlvfKkhWuvDxRQQwXycYS+8z8u4VA4Kq+RL+hGwWBlalq1NVZTOftxmwybVq1daVBAptU77VNnG0MEtdur7qGfWvEh3xaL9FI1WOMW5GxnkLh5ngjIXjHdMPc/HG7V4fQTQEbROWLWneUVRWKECtNYU7B0ufBatmvB8BllEkJVHr5FQOfMpsaAINkEEBZpetw/n1IPXet5qILLICGK1wKVHs9BUlObaPqezB1GKLCmQG0/HyZ9//P7gCJ6ncd/488jDq4BWPck/q45rbvPUoNWBpLTTo8M2CigSSuUQFLmM4jeJgjuq+C3MiP+6kPIsHSjhz9+HIKwNqBKE2Eb7Ih+XnHiGlw3yptY8XSiS+23P/FHJMf0AbyRwCNrzM6YwbfucuWRnLEc+s4+4nddEYvhKdndX9/RkpcRsiiTU5uxFkKJqeYXd1RNAFEVHB7VNr8tSw7oG4uNO3FFzRjc5RQaQCSbOwORv4UnmGshf95M80A1xbRcqpQw4tftWECtUYvY9AyYzZT9TgvR+1U2tbbar5LJW95zV6YRFTgOSr6+y5gRr5z26ik2rtRvJccBc0jyW4e5o2mQk/DfsOume877waD0ngpNyQxppWeSrtTKJS8UCNQizpCF4iz2mZauRxBWvK57PDjLw6zG3vQWTYeLVuWy/iv6UhmQdcwsPJ4web7IZ2SqXP0COWI4OcUb5v/oPHfIC4+UrVDF3W4p6skHbML1mV/PJ8jIi0hSmJGb9xZEQJQtb2xa0J/Fb1ohItHtk1OGC6aKtbesQ2+IiZmkj3nvIS5kg/FAiDSZwiZljYO00Mx7CMFdrOTiO/QbVeMJi9joLnSxweHyaMCUW96klPv8UuhYHBXANz2LKGv3JzAVcaVOFjbncBuS+SBCriVW4xz3LMOZDGt+dwweYuJQTOmG8hMk/5OTA4/+YoThdERaDrEaY+C3AHIgwsAvTsLBxfrakFa4w3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAijZgVPiaqE5xfmVoS1rgoNE5801i7AI+iWU9C4gWKTaCru9sEL+XedxRom0sZjL672Za6gt1ILAzZ+T26XJSPEPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvJ8qczwFCmSOmHYcsfCJMQmRoHJE2ov3nE3M173Fv7N4ZKxptOxTf5amtY5UdLXZt9e5ME1hEP1oUCGtRluE+Rg==",
+      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-7910244512f567b2c80618688fdf51d9-client-ivc-true"
+    },
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfNaoQwFAXgd8k6C29+jJlXKWWIGodAiBK1UMR3b5RpO8wsh7MRb7h+AcmB3I31vl1v15CGcWaXj43FsXNLGFOptp2zNocYw+36uMyq42Hl2T9PLh3lvLi8sIvUkjOf+vJWU/l+CNGfqzt/6TXi3mrMX6cW+ydnVgFtDbRroG2AdgO0Lc6mqkLihMQFEpdIXCFxjcRrJG6QeIPEkQklZEIJmVBCJpSQCSVkQgmZUHo7ofa3tfziF91A9QaqW6QuKqhOUF1AdQnVFVTXUB2aVQHNqoBmVeCyupfqy+Xg2ujvI9qwpu5hYlu+J/80vE157Hy/Zn+Mcf8T3HGypeJKnZeAUpAUnKQpm5SNfgA=",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndJLCoMwEAbgu8zahXmp8SpSJGqUQEgkxkIR794ottjiJm6GzJBvZvMv0MlmHmplejtBWS2gbSu8siZ0y5pA45TWaqjPY0i3gtD+fxqF2drJC+ehJIwkIE0XXhkKvlda7tP1kQDC8YTEExpPWDTBl1c44dlhOMXkizjaDbthshsmv2GKeEMuI8BpwT6GpfTHrKF7CqdEo+WRsH427Slw/jXKv+yNzraym53cUngKYKgVyhOMw9qw+g0=",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "_check_timestamp",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "11405868724477732285": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called internally"
+          },
+          "13418685691864489983": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called statically"
+          },
+          "1433889167918961673": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 17
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "8443716675528357851": {
+            "error_kind": "string",
+            "string": "Timestamp mismatch."
+          }
+        },
+        "parameters": [
+          {
+            "name": "operation",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 8
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "value",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 64
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgMEAiYCBAQAHxgABAADgEMdAIBDgEMCHQCARIBEBS0IgEMAAS0IgEQAAiQAAABUJwIAAQSARSYCAgQAOg0AAQACJAAAAy4eAgAEAR4CAAUACjgEBQYjAgAGAAAAdSQAAANXHgIABAkmAgUAAQo4BAUGIwIABgAAAJEkAAADaR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYmAgQCAQo4AQQFJgIEAQEjAgAFAAADFyIAAADGJgIHAgIKOAEHCBYMAgcjAgAIAAADBSIAAADhJgIJAgMKOAEJCiMCAAoAAALzIgAAAPgmAgoCBAo4AQoLIwIACwAAAtwiAAABDyYCCgIFCjgBCgsWDAYKIwIACwAAAsUiAAABKiYCBwIGCjgBBwsjAgALAAACsyIAAAFBJgIBAmUmAgcCICYCCgJsJgILAm4mAgwCdCYCDQJwJgIOAmQmAg8CSSYCEAJhJgIRAnImAhICbyYCEwJpJgIUAnYsCAEVJgIWBBIAEAEWASYDFQQBACgVAhYsDBYXLA4PFwAoFwIXLA4LFwAoFwIXLA4UFwAoFwIXLA4QFwAoFwIXLA4KFwAoFwIXLA4TFwAoFwIXLA4OFwAoFwIXLA4HFwAoFwIXLA4SFwAoFwIXLA4NFwAoFwIXLA4BFwAoFwIXLA4RFwAoFwIXLA4QFwAoFwIXLA4MFwAoFwIXLA4TFwAoFwIXLA4SFwAoFwIXLA4LFyYCAQQAJgIHAQAKOAcECiMCAAoAAAKqJgILBBMsCAEMJgINBBMAEAENASwMDA0pAwANBRPmMpnlFxQJACgNAg0AKBUCDiYCDwQRLQQADoADLQQADYAELQQAD4AFJAAAA3smAg4EEQA4DQ4NLA4BDQAoDQINOw0MCywMBwYiAAACvCwMCgYiAAACvCwMBgIiAAAC0wQ4CgcBLAwBAiIAAALTLAwCCSIAAALqEjgGAgEsDAEJIgAAAuosDAkIIgAAAvwsDAYIIgAAAvwsDAgFIgAAAw4sDAcFIgAAAw4sDAUDIgAAAyAsDAIDIgAAAyAjAgADAAADLSQAAAPBJScAgAQEeAANAAAAgASAAyMAgAMAAANWKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQWeScksjTulvTsBAQIlKQEAAQW6OL+KoDMf/zsBAQIlAQCAA4AFgActAIADgAgtAIAEgAkLAIAIgAeACiMAgAoAAAPALQGACIAGLQKABoAJAQCACAACgAgBAIAJAAKACSIAAAOPJSkBAAEFdS4blGTo99s7AQECJS0AGMoYyg==",
+      "debug_symbols": "zVpbTiMxELzLfOfD7X7ZXGWFUICAIkUJCmGlFeLuO5PNTEJmlojgkvyDMOpOdZVdjWP7vXlc3L893y3XT5vX5ubXe7PaPMx3y826Hb1/zJr77XK1Wj7fnf65Cd2PlPfxry/zdTd83c23u+aGLIdZs1g/tr96CO0nPC1Xi+aGlT9mo2hR5UO0qNEQbToRnGKIh+AUyU+Db2dNlgLlcEp9OZz9QjnE2pdDSuflfFudNomCXJNF8aos/7lg5kKHaHO9JFjKw/xl0jPBKF7FIvo1WXwVloSrsnQqK1s+JOVkF1TWHPuVppntgsrK0qusGs9V1nChmpNl3zPQSQYUYu9dCjzOsmm1gsqQleUCc86DH0MaYonsH4L+HEGiDY6PnxAmVruGvhxTPjqe8lTpcZg0jszH4DQRHNMQHJPY18EpaL/gUnA+LaNTxQvoLjLo7jLS3RWNkNPPEZR6lfRkdR4QYmA4QgEOHvpg5zBCiAXmQb0PtjBG4IBGkAIqGfeNyGyMoIxGcELPtBsaIZXg4Db0JR4hlPD0lwhcwtNfI0SCIxgageEcGM5B4BwEzkHhHBTOweAcDM7B4RwczgHevTnBOeQAR1AwgoQAR4BzIDgHEjgCeq8hkeEIjkb4zylISQR01xD4TkAE7jiFO07hjtOMRjC44wzeNRzuOId3DfheQ+B7DYHvNQS/18hox2kQOALacUoMR0A7TmOEI6Adp/BTB2W041QCHAHuOIF3DYU7TuFdwwo4Lkl/Zpz883nrRDX9xagf7xHau7t9KV5NKV6PKl6PKkmrKaXEtqZUKVJPKbmWUixUo4qV2HoVKqXErUqpUqyaUrgeVbgeVaSa/0Em9ThI6+krWk+3tXpUsXpUca6nlGoc5KHE9yIZPn/8SsRLnLbbwMDS6D1c+v7t0z7r25Nw+9EOf8+3y/n9anF4J/z0tn44eTa8+/OyOHtB/LLdPCwe37aL7i3x8RlxtxqppUUp3nYvYLuhhRmZdkPaD/OMnFrUFvkv",
+      "brillig_names": [
+        "_check_timestamp"
+      ]
     },
     {
       "name": "_check_block_number",
@@ -1704,7 +1886,7 @@
         "return_type": null
       },
       "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgMEAiYCBAQAHxgABAADgEMdAIBDgEMCLQiAQwABLQiARAACJAAAAE0nAgABBIBFJgICBAA6DQABAAIkAAADHR4CAAQBHgIABQAKOAQFBiMCAAYAAABuJAAAA0YeAgAECSYCBQABCjgEBQYjAgAGAAAAiiQAAANYHgIABAUKOAQCBQw4BAIGJgICAgEKOAECBCYCAgEBIwIABAAAAwYiAAAAtSYCBwICCjgBBwgWDAUHIwIACAAAAvQiAAAA0CYCCQIDCjgBCQojAgAKAAAC4iIAAADnJgIKAgQKOAEKCyMCAAsAAALLIgAAAP4mAgoCBQo4AQoLFgwGCiMCAAsAAAK0IgAAARkmAgcCBgo4AQcLIwIACwAAAqIiAAABMCYCAQJ0JgIHAnAmAgoCZCYCCwJhJgIMAkkmAg0CciYCDgJvJgIPAmkmAhACdiYCEQJlJgISAiAmAhMCbCYCFAJuLAgBFSYCFgQSABABFgEmAxUEAQAoFQIWLAwWFywODBcAKBcCFywOFBcAKBcCFywOEBcAKBcCFywOCxcAKBcCFywOExcAKBcCFywODxcAKBcCFywOChcAKBcCFywOEhcAKBcCFywODhcAKBcCFywOBxcAKBcCFywOERcAKBcCFywODRcAKBcCFywOCxcAKBcCFywOARcAKBcCFywODxcAKBcCFywODhcAKBcCFywOFBcmAgEEACYCBwEACjgHAgojAgAKAAACmSYCCwQTLAgBDCYCDQQTABABDQEsDAwNKQMADQUT5jKZ5RcUCQAoDQINACgVAg4mAg8EES0EAA6AAy0EAA2ABC0EAA+ABSQAAANqJgIOBBEAOA0ODSwOAQ0AKA0CDTsNDAssDAcGIgAAAqssDAoGIgAAAqssDAYFIgAAAsIEOAoHASwMAQUiAAACwiwMBQkiAAAC2RI4BgUBLAwBCSIAAALZLAwJCCIAAALrLAwGCCIAAALrLAwIBCIAAAL9LAwHBCIAAAL9LAwEAyIAAAMPLAwFAyIAAAMPIwIAAwAAAxwkAAADsCUnAIAEBHgADQAAAIAEgAMjAIADAAADRSkBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFce1fE3G+NAY7AQECJSkBAAEFkKJCubMVTz47AQECJQEAgAOABYAHLQCAA4AILQCABIAJCwCACIAHgAojAIAKAAADry0BgAiABi0CgAaACQEAgAgAAoAIAQCACQACgAkiAAADfiUpAQABBR8gi4cBmc/9OwEBAiUtABjKGMo=",
-      "debug_symbols": "zVrbbuIwEP2XPPPg8Vw87q+sqoq2tEJCUFG60qrqv2/SJYGSdFHBR/ILwjDmXJKZDLbfm8fF/dvz3XL9tHltbn69N6vNw3y33Kzb0fvHrLnfLler5fPd8cdN6F48fsa/vszX3fB1N9/umhuyHGbNYv3Yvk0htL/wtFwtmhvW+DEbRYsq76NFjYboLBPBHkPcB3ukdBx8O2s8FaDD7j0dzukMHWLt6ZDSCZ38Y3e6SemCSRT0klkUrvfLktA+2pKe88vzcPky6YlfRBepiOGiWRdhMV80y6dnxdzPMslnfNZk/a2mKeUzPov1N7GL51Of5RsVkQY+6dx15zykSfAhllT/Ifj1CBJtSMT4BWHiLtTQ0zHlQyJSnqIeY28lR+ZDsE8ERx+CY2vr/4M9aH8jeEh8TKNzRQv4LjL4nmTkuzoawel6BKXeJeU0RjA0Qi6gIQXZBycOpwgxFLgOmnoEC2MEYjQCF3DJuH+2m00gGBpBBX2lNaMRrISGZENd4hFCiZw+g2BgBA4CR8hoBIJrILiGCNcQ4RoYroHhGgSuQeAaFK5B4Rrg1ZsNriExHMHRCA7X4HANGa7hu9WHYggSCI6A7jXku3WTgggKR0BXDYF3AhLRGSfMcAR4xkmEI8AzTuFVQ+EZZ/CqAe81BN5rCLzXEHivIQ7POIdXjQzPuIyuGhoCHEHhCOiMU/iqgxI64zQyHAGdccoRjgDPOCE4QoGMc+nXjD19XW+dYNNvWKbDPkK709tR0VAPlXpcsXpcMa+GSom2phSVVA2VEo1SKSr1uFKi9SpDxYLUQyVXQ4XqcYXqcSVW8wwyrieDuJq6YlJNtTWpxxWtxxW1aqhYPRmUS/wvkuH3x6dEUonVdhsUmI/Ow6Wf7z51s37eCNx+tMPf8+1yfr9a7I/vPr2tH45O8+7+vCxODva+bDcPi8e37aI74ns43dtxJsszSvm2O2PaDTXNWvxuSJ/fcjvUFrVF/gs=",
+      "debug_symbols": "zVrbbuIwEP2XPPPg8Vw87q+sqoq2tEJCUFG60qrqv2/SJYGSdFHBR/ILwjDmXOKZDI7fm8fF/dvz3XL9tHltbn69N6vNw3y33Kzb0fvHrLnfLler5fPd8cdN6F48fsa/vszX3fB1N9/umhuyHGbNYv3Yvk0htL/wtFwtmhtW/piNokWV99GiRkO06USwxxD3wR4pHQffzhpPBeiwe0+HczpDh1h7OqR0Qif/2J1uUrpgEgW9ZBaF6/2yJLSPtqTn/PI8XL5MeuIX0UUqYrho1kVYzBfN8ulZMfezTPIZnzVZv9Q0pXzGZ7F+Ebt4PvVZvlERaeCTzl13zkOaBB9iiewfgl+PINGGRIxfECZWoYaejikfEpHyFPUYeys5Mh+CfSI4+hAcW1v/H+xB+4XgIfExjc4VLeC7yOB7kpHv6mgEp+sRlHqXlNMYwdAIuYCGFGQfnDicIsRQ4Dpo6hEsjBGI0QhcwCXj/t5uNoFgaAQV9JXWjEawEhqSDXWJRwglcvoMgoEROAgcIaMRCK6B4BoiXEOEa2C4BoZrELgGgWtQuAaFa4BXbza4hsRwBEcjOFyDwzVkuIbvdh+KIUggOAK615Dv9k0KIigcAV01BN4JSERnnDDDEeAZJxGOAM84hVcNhWecwasGvNcQeK8h8F5D4L2GODzjHF41MjzjMrpqaAhwBIUjoDNO4bsOSuiM08hwBHTGKUc4AjzjhOAIBTLOpd8z9vR1v3WCTf/AMh2eI2j8pKKhHir1uGL1uGJeDZUSbU0pKqkaKiUapVJU6nGlROtVhooFqYdKroYK1eMK1eNKrOYeZFxPBnE1dcWkmmprUo8rWo8ratVQsXoyKJf4XyTD749PiaQSu+02KDAfnYdLP3/61M36eSNw+9EOf8+3y/n9arE/vvv0tn44Os27+/OyODnY+7LdPCwe37aL7ojv4XRvx5kszyjl2+6MaTfUNGvxuyF9fsvtUFvUFvkv",
       "brillig_names": [
         "_check_block_number"
       ]
@@ -2069,7 +2251,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::header::Header"
+                    "path": "aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -3179,7 +3361,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "aztec::protocol_types::header::Header"
+                  "path": "aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -3291,195 +3473,13 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZXbisIwEIbfJde9mMnkMPFVFpGqVQqllVoXFvHdNylNW92ArHsAwZuSaf7J/HwzTc9iW6xP+1VZ75qjWLydRdVs8q5sah+dBer+3fGQ1yE8dnnbiQUaB5ko6q1fWoBLJnZlVYgFaXnJvqglEw9qyWZSo0qpSaMb1KSdvKN2wHZQOwQc1VJCQo2WKfpmmM6WJiUGaaIYrJ6Ll5lA8wKTBmNfYNJg+OdgyFk5qBUAj2pHfQX31xUkpCpYGVMY1J3zEYD0CAlmzXUppJqjd4MTUETu3eAvuLEjHMBZiaQbZDuOml+TmeNJjDE6HQfCr1nf0pRP7p/+278jiod7b0hXhnywbsuqKverq38YhIdKskZfNJ6Hkm8HTNEjSeqRJP1Ikvl2ko8waNMfsr89h0yr3ZTob8blxYfveVvm66oIVMPuqd5EyD7sPg5xJ7bh0DabYntqi9CQqReBKkGmINxZwYjiTNPorX8lKZPsq/rKnw==",
+      "debug_symbols": "7ZXbisIwEIbfJde9mJmcJr7KskjVKoXSSq0Li/jum7hNo25A1j2A4E3pJN9kfv6Zpgexqhb7zbxu191OzF4OoumW5VB3rY8OAvVpbbct2xDuhrIfxAyNg0JU7cq/WoBjIdZ1U4mZ1PJYfKGJJY80sUk0Wp2hpUY30lI7ukGzs3qk2bFLShAzNFqWUTdDOptMDgYyEYZQPMGvhUDzNCZvjH0akzeGf26MAh3FK3A40eazgvvrCgS5CpYoOgrqxvkIIPVkEpw117gMrjlqN5gMZTqJwV8QYydvAM8qZMWgQ2Uj7tCoc3cyU0ySVRxjUiivzaQH1y//Xb81E+6cupxOHyz6umnqzfziFwbhobJeoy8az0Piq/lS8o4cdUeOviPHfDfHBxjQ/Cfs780x0ep0J7L1eT56K/u6XDRV8DNs7ttltNeHw/s27sQGbPtuWa32fRVakboQDJVQKAiXVdChuNByknZaIlkQ+6q+8gc=",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal"
       ],
-      "verification_key": "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",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-fad3e9d196065cb9425cd182d29ccab4-mega-honk-true"
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "10421965853029650238": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called statically"
-          },
-          "11405868724477732285": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called internally"
-          },
-          "13418685691864489983": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called statically"
-          },
-          "1433889167918961673": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 17
-          },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2242946026394210301": {
-            "error_kind": "string",
-            "string": "Block number mismatch."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "8209322232883590150": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called internally"
-          },
-          "8443716675528357851": {
-            "error_kind": "string",
-            "string": "Timestamp mismatch."
-          }
-        },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLBCoQgEAbgd/HcITUze5VYwspCEA2zhSV699XddmmXLnoZnMFv5vJvYBDdOrVSj2YBdbMBZXrupNG+2/YMdFYqJaf2PAZ5KBC+/i8z16FdHLcO1JjgDAg9+FcJvR+lEmGK9lsGIIonOJ4U8YREE3R5hRUkPwwrKP0iCN+IpKAyBdEUVCUgfJkDRjD7IEKqX7T79s6t5J0SR87GVfen2LnHLP4SOFvTi2G1ImTxFENfG0gzhPxav/oJ",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfNaoQwFAXgd8k6C29+jJlXKWWIGodAiBK1UMR3bzJM26GzLGcj3nD9ApIDuQcbfb/friFN88oubweL8+C2MKdSHSdnfQ4xhtv1eZk19WHlvX9dXKrlurm8sYvUkjOfxvLWUvl+CtHXVXHyl14jHq3G/HRqOt85swpoa6DdAm0DtDugbXE2NQ0SJyQukLhE4gqJayTeInGDxDskjkwoIRNKyIQSMqGETCghE0rIhNK/E2q/W8svftENVO+gukXqooHqBNUFVJdQXUF1DdWhWRXQrApoVgUuq2epPlwOro/+MaJNexqeJrbtc/F/hrclz4Mf9+zrGPc7wdWTLRVX6n4JKAVJwUmasknZ6As=",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-fad3e9d196065cb9425cd182d29ccab4-client-ivc-true"
     }
   ],
   "outputs": {
@@ -3563,17 +3563,19 @@
                   {
                     "name": "value",
                     "type": {
-                      "kind": "field"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 64
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::_check_block_number_parameters"
+                "path": "Router::check_timestamp_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::_check_block_number_abi"
+          "path": "Router::check_timestamp_abi"
         },
         {
           "fields": [
@@ -3592,19 +3594,17 @@
                   {
                     "name": "value",
                     "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 64
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::check_timestamp_parameters"
+                "path": "Router::_check_block_number_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::check_timestamp_abi"
+          "path": "Router::_check_block_number_abi"
         }
       ]
     }
@@ -3622,55 +3622,55 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "51": {
+    "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "93": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\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        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
-    },
-    "94": {
+    "65": {
       "path": "/usr/src/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::{Deserialize, Empty, Serialize};\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_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // 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        // 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        // 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        // 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 args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\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 args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\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        // 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        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // 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        // 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        // 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        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // 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        // 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        // 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        // 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        // 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        // 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            // 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: Deserialize<N>,\n    {\n        T::deserialize(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            // 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: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\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_unencrypted_log(message: [Field]) {\n    emit_unencrypted_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]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\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\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#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_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) -> bool {}\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) -> 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"
     },
-    "96": {
+    "66": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\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        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+    },
+    "69": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
-    "112": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
-    },
-    "118": {
+    "82": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
       "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
     },
-    "120": {
+    "87": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "142": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
+    "91": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "155": {
+    "116": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum =\n    ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            !compare(lhs, Comparator.LTE, rhs),\n            \"Expected lhs to not be less than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n    }\n}\n"
     },
     "175": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
+    },
+    "241": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
+    },
+    "291": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self.to_integer()]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "220": {
+    "311": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::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,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__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, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\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: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\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.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\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            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    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 = std::hash::sha256(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"
-    },
-    "308": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
-      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::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,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, 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    tx_hash: 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(tx_hash, 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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\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: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\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.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\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\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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 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 = std::hash::sha256(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"
     },
-    "352": {
+    "353": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/router_contract/src/main.nr",
       "source": "mod test;\nmod utils;\n\nuse dep::aztec::macros::aztec;\n\n/// The purpose of this contract is to perform a check in public without revealing what contract enqued the public\n/// call. This is achieved by having a private function on this contract that enques the public call and hence\n/// the `msg_sender` in the public call is the address of this contract.\n#[aztec]\ncontract Router {\n    use aztec::{macros::functions::{internal, private, public, view}, utils::comparison::compare};\n\n    // docs:start:check_timestamp\n    /// Asserts that the current timestamp in the enqueued public call satisfies the `operation` with respect\n    /// to the `value.\n    #[private]\n    fn check_timestamp(operation: u8, value: u64) {\n        Router::at(context.this_address())._check_timestamp(operation, value).enqueue_view(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    #[view]\n    fn _check_timestamp(operation: u8, value: u64) {\n        let lhs_field = context.timestamp() as Field;\n        let rhs_field = value as Field;\n        assert(compare(lhs_field, operation, rhs_field), \"Timestamp mismatch.\");\n    }\n    // docs:end:check_timestamp\n\n    /// Asserts that the current block number in the enqueued public call satisfies the `operation` with respect\n    /// to the `value.\n    #[private]\n    fn check_block_number(operation: u8, value: Field) {\n        Router::at(context.this_address())._check_block_number(operation, value).enqueue_view(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    #[view]\n    fn _check_block_number(operation: u8, value: Field) {\n        assert(compare(context.block_number(), operation, value), \"Block number mismatch.\");\n    }\n}\n"
     }