@aztec/protocol-contracts 0.77.0-testnet-ignition.30 → 0.77.0

package/artifacts/Router.json

@@ -3,124 +3,6 @@
   "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
   "name": "Router",
   "functions": [
-    {
-      "name": "_check_block_number",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "internal",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "10421965853029650238": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called statically"
-          },
-          "1433889167918961673": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 17
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2242946026394210301": {
-            "error_kind": "string",
-            "string": "Block number mismatch."
-          },
-          "8209322232883590150": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called internally"
-          }
-        },
-        "parameters": [
-          {
-            "name": "operation",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 8
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "value",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "JgACBAEnAAABBIBLJgAABAMmAgMEAiYCBAQAHxgABAADgEkdAIBJgEkCLQiASQABLQiASgACJAAAAFIkAAAAfScCAAEEgEsmAgIEADoNAAEAAicAgEMCAAQnAIBEAgAGJwCARQIAAScAgEYCAAInAIBHAgAFJwCASAIAAyUkAAADQR4CAAQBHgIABQAKOAQFBiMCAAYAAACeJAAAA2oeAgAECSYCBQABCjgEBQYjAgAGAAAAuiQAAAN8HgIABAUKOAQCBQw4BAIGCygAAYBFAAImAgQBASMCAAIAAAMqIgAAAOMLKAABgEYABxYMBQgjAgAHAAADGCIAAAD8CygAAYBIAAkjAgAJAAADBiIAAAERCygAAYBDAAojAgAKAAAC7yIAAAEmCygAAYBHAAoWDAYLIwIACgAAAtgiAAABPwsoAAGARAAIIwIACAAAAsYiAAABVCYCAQJ2JgIIAm8mAgoCaSYCCwJlJgIMAiAmAg0CbCYCDgJuJgIPAnQmAhACcCYCEQJkJgISAmEmAhMCSSYCFAJyLAgBFSYCFgQSABABFgEmAxUEAQAoFQIWLAwWFywOExcAKBcCFywODhcAKBcCFywOARcAKBcCFywOEhcAKBcCFywODRcAKBcCFywOChcAKBcCFywOERcAKBcCFywODBcAKBcCFywOCBcAKBcCFywOEBcAKBcCFywOCxcAKBcCFywOFBcAKBcCFywOEhcAKBcCFywODxcAKBcCFywOChcAKBcCFywOCBcAKBcCFywODhcmAgEEACYCCAEACjgIBAojAgAKAAACvSYCCwQTLAgBDCYCDQQTABABDQEsDAwNKQMADQUT5jKZ5RcUCQAoDQINACgVAg4mAg8EES0EAA6AAy0EAA2ABC0EAA+ABSQAAAOOJgIOBBEAOA0ODSwOAQ0AKA0CDTsNDAssDAgGIgAAAs8sDAsGIgAAAs8sDAYFIgAAAuYEOAsIASwMAQUiAAAC5iwMBQkiAAAC/RI4BgUBLAwBCSIAAAL9LAwJByIAAAMPLAwGByIAAAMPLAwHAiIAAAMhLAwIAiIAAAMhLAwCAyIAAAMzLAwFAyIAAAMzIwIAAwAAA0AkAAAD1CUnAIAEBHgADQAAAIAEgAMjAIADAAADaSkBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFce1fE3G+NAY7AQECJSkBAAEFkKJCubMVTz47AQECJQEAgAOABYAHLQCAA4AILQCABIAJCwCACIAHgAojAIAKAAAD0y0BgAiABi0CgAaACQEAgAgAAoAIAQCACQACgAkiAAADoiUpAQABBR8gi4cBmc/9OwEBAiUtABjKGMo=",
-      "debug_symbols": "zVrbTuMwEP2XPufB47maX1khVCCgSlWLSllphfj3TaBOQ5NS2mYkvyBczfScOfEZu7HfZ4/1/dvz3WL1tH6d3fx5ny3XD/PtYr1qRu8f1ex+s1guF893/Y9nof0DGD4TXl/mq3b8up1vtrMbAIxYzerV4+f/BM2XPC2WdTOK4aMaxJNA3IWTtBG7aMWRYEMOu2BD4X7wbdUw4iOMSPeMRE8xIkyZEZGdYBQtV2sxpUNG9BuNJH1j9JnHl+UxXphn43lG0uWZ2AnlxCwLLSngz8qlQPlZpiB4qJzgLxhpGFQidlmeXohncGGejOYJdlNVeD9TBUYUZJP8VNlUT0xUgUyoSdNDudN4GRJTR0ftZzqYLNsm9GaK2ReAXA1AMVdAGL8BjMwuNMqzi0LP8mPByB11lCD7YB0LhpTnLUaAn4MBgnI3D0Lq69LKEsP1ujc9KsuidKh7jHo1AEMumFEHAEea7jkAGvKzUgwDAI7XV6AZQMIQ4Ij1zwEQzE4UGQIk8pUIw/USqXbtode5MwAkZ4AjC+WEAOwMwN4VsHcF4l2BeFeg3hWodwXmXYF5V5C8K0jOFVAI3gDuFTi3awLyBvCuIHpXEL0rQPQGUGcAit4A4gzA4A3g3Sq8F30Sb6OJt9HU22hqzgDmbTTzbhXJ22jJuVWw966CvXcV7L2rYO9dBYOz0TiiN4Cz0RijN4C30Qi8AbyN5v0qgdnbaOzdKsTbaOLdKtTbaOrdKux6oxl1p2f6/bXmCJl8Ttg76mD4YiKlMEnFaJJK0UQCFcMklcIEsBgmVgqTWIwmE+yyJmIywbnIVEy4FCZcjCZcjCZSyrojUox3tJh+osX0WCtGEytGkxSLYVKKdzRO8POHuq8f3onQCd6cS8dfbHDhyM4+QWqTzl74bz+a0d/5ZjG/X9a7O5NPb6uH3hXK7b+X+uA25ctm/VA/vm3q9l7l/kpl601QqMCgIQPtMgecKhBqh61gIFaBhga1Qf4P",
-      "brillig_names": [
-        "_check_block_number"
-      ]
-    },
-    {
-      "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": "JgACBAEnAAABBIBLJgAABAMmAgMEAiYCBAQAHxgABAADgEkdAIBJgEkCHQCASoBKBS0IgEkAAS0IgEoAAiQAAABZJAAAAIQnAgABBIBLJgICBAA6DQABAAInAIBDAgAEJwCARAIABicAgEUCAAEnAIBGAgACJwCARwIABScAgEgCAAMlJAAAA1IeAgAEAR4CAAUACjgEBQYjAgAGAAAApSQAAAN7HgIABAkmAgUAAQo4BAUGIwIABgAAAMEkAAADjR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYLKAABgEUABCYCBQEBIwIABAAAAzsiAAAA9AsoAAGARgAHFgwCCCMCAAcAAAMpIgAAAQ0LKAABgEgACSMCAAkAAAMXIgAAASILKAABgEMACiMCAAoAAAMAIgAAATcLKAABgEcAChYMBgsjAgAKAAAC6SIAAAFQCygAAYBEAAgjAgAIAAAC1yIAAAFlJgIBAkkmAggCZCYCCgJhJgILAnImAgwCbyYCDQJpJgIOAnYmAg8CZSYCEAIgJgIRAmwmAhICbiYCEwJ0JgIUAnAsCAEVJgIWBBIAEAEWASYDFQQBACgVAhYsDBYXLA4BFwAoFwIXLA4SFwAoFwIXLA4OFwAoFwIXLA4KFwAoFwIXLA4RFwAoFwIXLA4NFwAoFwIXLA4IFwAoFwIXLA4QFwAoFwIXLA4MFwAoFwIXLA4UFwAoFwIXLA4PFwAoFwIXLA4LFwAoFwIXLA4KFwAoFwIXLA4TFwAoFwIXLA4NFwAoFwIXLA4MFwAoFwIXLA4SFyYCAQEAJgIIBAAKOAEFCiMCAAoAAALOJgILBBMsCAEMJgINBBMAEAENASwMDA0pAwANBRPmMpnlFxQJACgNAg0AKBUCDiYCDwQRLQQADoADLQQADYAELQQAD4AFJAAAA58mAg4EEQA4DQ4NLA4IDQAoDQINOw0MCywMAQYiAAAC4CwMCwYiAAAC4CwMBgIiAAAC9wQ4CwgBLAwBAiIAAAL3LAwCCSIAAAMOEjgGAgEsDAEJIgAAAw4sDAkHIgAAAyAsDAYHIgAAAyAsDAcEIgAAAzIsDAgEIgAAAzIsDAQDIgAAA0QsDAIDIgAAA0QjAgADAAADUSQAAAPlJScAgAQEeAANAAAAgASAAyMAgAMAAAN6KQEAAQX3ofOvpa3UyjsBAQIlKQEAAQWeScksjTulvTsBAQIlKQEAAQW6OL+KoDMf/zsBAQIlAQCAA4AFgActAIADgAgtAIAEgAkLAIAIgAeACiMAgAoAAAPkLQGACIAGLQKABoAJAQCACAACgAgBAIAJAAKACSIAAAOzJSkBAAEFdS4blGTo99s7AQECJS0AGMoYyg==",
-      "debug_symbols": "zVrbTuNADP2XPPfBHntsz/7KCqECAVWqWlTKSivEv2/S7aSBhBaaWJoXRMDuuSTHmSbzVj3Ud69Pt6vN4/al+vX7rVpv75f71XbTHL29L6q73Wq9Xj3d9v9cQfsDSQ8NL8/LTXv8sl/u9tUvRAq0qOrNw+F3xuZDHlfrujkK8L4Y1LNgOJaztBXHaqWRYqMIx2Ijif3im0WFHL5gxHpiJHqJEVPKjJjtAqNgWa2FlAaMvuORpA+M2r4YrusTuLIvjvcZS9dnYhecE7NstCSg884l4HwuEwh9dk7hG4wUBko0XtdnV+KZXdeXaKwvaTYwJe56BMfMBsJsNnC4cJmK5ZQ1ZOCz2cnOk0GA2GfT9AQYFYAnVgg8bBp3CyR0ZkE4r5uS5XRC74I0OwAgTQbgkM8cU/gAMHIRk3E+YQy9yTJWTLGjTgJyKtaxYkw5HhQQzxc3ojSeBKa+L/9tme57MwqzLcoD35knA0TMgiPpAOCLifgTAIV8rpRgACBpugLlLpFDgASTAYTyGBcZABCir0XNJTkdQHO4rHeDyAAkzgBRnQEkeAN4K1BvBeqtwLwVmLeC5K0gOStgCN4A3grQWwF6KwjeCoLzuGZCbwBvBeytgL0VRPAGYG8A52ULC3kDmDOA902fvW/6bN5BM++gJe+gpegN4By0COwN4By0iOQN4By06L2qiN6riui9qojkHLTI4A3gHTT2HhXRO2jRe1R4P0qI3o8SonoHTb1HhXkHzbxHhXkHLXmPijQ9aMbdSzr9+FhzhEz+WD09hI6HtxcCVAyTYjzBYjwJWAwTKYUJQTFMYilMuBhPZlhlzcRkhvciMzGZYdUzF5NiPNFiPNFi7jtWTHZSMfMklTJjFUrxRKEcT1IpTLCU7CjP8PWHu48f7onQGZ6cS8dfbLDhyH78Bqlt+vGN/+a9Ofqz3K2Wd+v6uDXz8XVz39upuf/7XH/atPm8297XD6+7ut2+edq52a7YUXmBxg0ZbKOKDTKKtoftKhotNv/VBrVB/gc=",
-      "brillig_names": [
-        "_check_timestamp"
-      ]
-    },
     {
       "name": "check_block_number",
       "is_unconstrained": false,
@@ -1745,13 +1627,33 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VXRisIwEPyXPPchu8kmWX/lOKRqlUJppdaDQ/z3S8Qm6kWPwt2B4EvpJrPZycwmOYhVtdhv5nW77nZi9nYQTbcsh7prfXQQoE9ju23ZhnA3lP0gZqiJC1G1q/Br6ViIdd1UYgYoj8V3NBo7otFxRDPmwKzdGawkwmMwkGU8o4GcNBGOVuUWBzQjE9CJN3KONyijxsU1yCv0eyGAXtLck8a8pLknjc1Ko1gladwP0mgZ+WvAhLZ4quD+vALnKoByaeMm5RjIeuCkTR7opJOhDFwZSnQSd2+Gp4PyN+iQTHRYPaYDTCp2EJPmS4FyreycjL3Mkm/0RHj2DeB/bwAl2NjPUtnrFvXBoq+bpt7Mr14zGT46+6QRwHk5InnbYZqmp5jpKXZ6ipuY4iMIyLxjFE+9Jb5IVD7Rhx9lX5eLpgpahtl9uxyl9eHwuR1nRvG3fbesVvu+CjYkB5SvraDQEO6ScHi980SR22kIqVDSV/WVvwA=",
+      "debug_symbols": "7ZXdasMwDIXfxde5sCTLP32VMUbapiUQkpKmg1H67rNLYred2xHYBoPeBCs5so4/2fFRrKvlYftWt5tuLxYvR9F0q3Kou9ZHRwHq/G6/K9sQ7oeyH8QCFbtCVO06DA2fCrGpm0osAOWp+KpGbSY1WhfVDnNip+woJonwWAzsWI1qP9Y2ytFQbnJAPTkBlXyjy/kG0jRNrkBeqV8LAfxEcw+NfqK5h8Zk0ZCjhMZ+g0YBTmgUaIpqg+cK9tcruFwFIJsWfgFVQ7YHVprYA6sSJ80ZOWmOdjB5983wdlD+hB2WyY6jx3bA6WjIjy1eAspsIJIQ4ZNUeMMT4b8vAP96AShJxkMpGeDKkQ+Wfd009fbt6jaT4aGyV5qfYpyOWd7uMMXzU/T8FDM/xc5M8REEZb5j7HBMNOwuEskn+vC97Oty2VSBZfh6aFcTWh8OH7vpywR/13eran3oq9CG1AHytQkKBeFfEg6v7zxz9HZ+hVyQ9FV95U8=",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "enqueue_public_function_call_internal"
       ],
       "verification_key": "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"
     },
+    {
+      "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/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt/5MKZSdCtSJOoogZBIHoUSsvdORGioP5e5w+FyEqw4x31SZrMehjGBtosMyhpqKTOYndJa7VP9hqYEFyfvD2lK9UG6AAMXvWgYoFnP+yloY1MaqbU8sxsv+vaiH5z/2K7Lr0z1LZ2Ss8bLZotmqeTC58A/z8PZBdfosBhXspQj71jb0CxNfwE=",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "process_log",
       "is_unconstrained": true,
@@ -1865,10 +1767,12 @@
       ]
     },
     {
-      "name": "public_dispatch",
+      "name": "_check_block_number",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "public",
+        "internal",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1876,28 +1780,11 @@
             "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"
@@ -1906,22 +1793,23 @@
             "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",
+            "name": "operation",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 8
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "value",
             "type": {
               "kind": "field"
             },
@@ -1930,10 +1818,10 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "zV3Rbhs5DPwXP+dBFCWS6q8cDkXaukWAICnS9IBD0X+/depdb7x0FjcVt34p7GJHw5EoSiK18Y/dp/2H71/e3z18fvy2e/fXj93948fb57vHh+Hbj583uw9Pd/f3d1/ez/97lw7/UCsvgG9fbx8O37893z49795xyu1mt3/4NHykqkMTn+/u97t3RPzz75tdTgyhzENlJTmiho+2QBFDKIgrQ1xZERRnCAVxFYirCIKqBKEqgpKEoMz1DSolHVFUiV6hbpZPp8w0Pp6y5ul5/UXS8hYkGk8yzOotSLZQQlsoya5PUi2jT5KQnPsk5wKhGoJihlCKoPzIs4oSBFWhnvcjzxpK3ChHrdUx8qSD+7zpSkbjcmlcpme52C8GiWbQFM5QwhksmsE4nCFcw4XFqCdDD29NOjHoK4bls83y8dnWTiF7CIgHa0oqV2WN/TlrdGEN8VVZc1V9k6PnesnRc71wDmeIXpmGDVk4Q41mqOEaagln2Hh2kuUy7rqMeTE/Ra7Lni47KNSekpb21Ouyx9z+Kc1GcyqVtfMWceaRg7jMzmc5Oc8XoTHCF8lpfjpztA5nhkms1LOjXLHaw/yiJ/NF18wvPE7IUoqtmJ9t7BrLrZ2b37r3vrRX5r+Q1HiS6ucbe5NYBxI7HRvJxFZGW8xG55CW+O3RbmnKU7QkfDbalbi3+ZoWfUS2AUmWDUiYfpukqU57ydOzQt5ApylpJKnklWkt0yZ1sDydDzRLR8sppTo3/UBQfr9rKEmeuj/lBYNEM9QUzlDCGSyaQXI4g0YzaLgGDfdWC/dWC/elhtTOakPqWZIyhPLrWSJ2QrXVTqjTBm34LOUsOgvRFiR1AxK/kNGbZAsl/oq5Uq4WP0WwhhKOrzGJbFAtE81bkGyhxLZQYlsoaUixShpSJtQLSfQ1lCEoyhAKKUlqJgiF9LxyglDRCVYtFM5QwxlaNEPlcIbocoBKuIYLi1FHBu3hrb3KeartmqyxayrnqV1TOU/bVfVNi57rljicIXquG1E4Q/TKZDmFM8RriF5djTeenZnblB4os6zncX5aoSuzp3tlZcvimdUu1ac/VTyzukFdyyRtQWIbkGj36tOWxTPTDepaZhtU6KzRFiQdMuLC09SWWR7NLZ9Vk9H9qqmuTGyZ0sADTM+GuqUOHSRTDpBEbW77C4NEM1AKZyjhDBbNkHM4g0YzcLgGDvfWEu6tJdyX/FRQ3zpF87NBnUn8mm9vEt2ARLdQYv974F9QhqAaxNUQLkqJMRjGRhmDKQTLGFvG2BhjY4FgJWGwCsEqYTBMm2DaBNOmmDbFtBnmJYb5ZMO0NUgbpYzBIG1EjMGgyEVYLCEslhBj2hjTVgoGaxCsQtOUsKBAgmkTTJti2gzTZtg0xYIC+Xe0mKeNE8/Tf/4+S8e84uz0Xl+21kNOoca278eLju1bbPt+BOrYfvD4crD9F653dWvfD3f92vdvEndsP9h+Cbbff8uqY/vB/mPB/m/B87cF2x+8vnDi4PZj4z/787dOlw2qneoZx+LqUKNhBOSOhNBYOhGWJchPw6yBECb/fbwVkP8W3BoIYCopISA3eNYpdSlJHZABIH8btAZCmDLClBEmf2uxBnLjvdSxaiSze7cTyD8qrYEaAKoKgPys7hoI6IhK/mo5dfngnKdYZ0eQf+e25JFpGMhXIKeAyza+ajwUFGY3AbyH+eQBLGl2wVa9h6mNM5Tz/Iq2urXRpON9kOFzm2s9SvXrKWXqHy3L/inumNcpdFTWJcg/T2sa+0k5LUF+tK5aphnjgPzEtPBYlBVZgsQvIb5tnvhnHdWpojsr9E8gbgDITyusgSoAUoRJESZDmAxhagiT/8cm10DA4F54d2ENhDARwuSvqisgZGqof7ZfAflJyDUQoqkgmgqiyS9krIEEAAmiSRBNimhSRBMSWBQJLNoQTQ3QZCkjIGCcLtxpXgMhmpAYYUiMMCRGGBIjDIkRhsQIq4imimhCYoQhMeLCxcw1EKLJ3JXQynTLVtPKHv+NJIj5SahOrTf/6N6t9RraeotsnUpo66G2+3mIXq37aYRerftvI3RrPdT2Gmq7nx/p1bqE+oyE+ruGzlUNtT109WgtNL63wPiek58YHY5OI2SZfMkX7m3JxCN2lqX7OXz95/bp7vbD/f74sxGfvz98nP2KxPO/X/dnPyjx9enx4/7T96f94aclTr8qcZhChfSmZD30z6Hvc803ub58PVhWmG4K88A6MP8H",
+      "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCLgiASQABLgiASgACJQAAAFIlAAAAfSgCAAEEgEsnAgIEADsNAAEAAigAgEMCAAQoAIBEAgAGKACARQIAASgAgEYCAAIoAIBHAgAFKACASAIAAyYlAAADQR4CAAQBHgIABQAKOAQFBiQCAAYAAACeJQAAA2oeAgAECScCBQABCjgEBQYkAgAGAAAAuiUAAAN8HgIABAUKOAQCBQw4BAIGCygAAYBFAAInAgQBASQCAAIAAAMqIwAAAOMLKAABgEYABxYMBQgkAgAHAAADGCMAAAD8CygAAYBIAAkkAgAJAAADBiMAAAERCygAAYBDAAokAgAKAAAC7yMAAAEmCygAAYBHAAoWDAYLJAIACgAAAtgjAAABPwsoAAGARAAIJAIACAAAAsYjAAABVCcCAQJ2JwIIAm8nAgoCaScCCwJlJwIMAiAnAg0CbCcCDgJuJwIPAnQnAhACcCcCEQJkJwISAmEnAhMCSScCFAJyLQgBFScCFgQSABABFgEnAxUEAQAoFQIWLQwWFy0OExcAKBcCFy0ODhcAKBcCFy0OARcAKBcCFy0OEhcAKBcCFy0ODRcAKBcCFy0OChcAKBcCFy0OERcAKBcCFy0ODBcAKBcCFy0OCBcAKBcCFy0OEBcAKBcCFy0OCxcAKBcCFy0OFBcAKBcCFy0OEhcAKBcCFy0ODxcAKBcCFy0OChcAKBcCFy0OCBcAKBcCFy0ODhcnAgEEACcCCAEACjgIBAokAgAKAAACvScCCwQTLQgBDCcCDQQTABABDQEtDAwNKgMADQUT5jKZ5RcUCQAoDQINACgVAg4nAg8EES4EAA6AAy4EAA2ABC4EAA+ABSUAAAOOJwIOBBEAOA0ODS0OAQ0AKA0CDTwNDAstDAgGIwAAAs8tDAsGIwAAAs8tDAYFIwAAAuYEOAsIAS0MAQUjAAAC5i0MBQkjAAAC/RI4BgUBLQwBCSMAAAL9LQwJByMAAAMPLQwGByMAAAMPLQwHAiMAAAMhLQwIAiMAAAMhLQwCAyMAAAMzLQwFAyMAAAMzJAIAAwAAA0AlAAAD1CYoAIAEBHgADQAAAIAEgAMkAIADAAADaSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFce1fE3G+NAY8AQECJioBAAEFkKJCubMVTz48AQECJgEAgAOABYAHLgCAA4AILgCABIAJCwCACIAHgAokAIAKAAAD0y4BgAiABi4CgAaACQEAgAgAAoAIAQCACQACgAkjAAADoiYqAQABBR8gi4cBmc/9PAEBAiYuABjKGMo=",
+      "debug_symbols": "zVrbbuIwEP2XPOfB47m6v7KqKtqmFRKCitKVVlX/fRPahEACFMhIfqka5Mk5c5gzNrY/i+fq8eP1Yb58Wb0Xd38+i8XqabaZr5b10+dXWTyu54vF/PWh/3ERmj+AYRvw/jZbNs/vm9l6U9wBYMSyqJbP2/8J6pe8zBdV/RTDVzkYT5rsZzhZkG604shgY5SfwcYM/cH3Zc2IjzAi3TESPcdIIreMBOkMI5LUMiLjQ0b0G40k7THaxvF1cYxXxtl4XJ1eF2diZ5TToC2MBkunlUsxtu9OkdKhcoK/YKRhkInYdXF6JZ7BlXEyGifYlarwrlIFRhSUQG3tSRA8U6gWYluoFvFQ7jSehsTU0VE7TQd3Rg69SjH7BpCbAagrGMK4BzBSXWjUVheFnuXHBiN31FF6PQh0bDCk0A6OAKcHAwTlrg5C6uvSyBLD7boTdborHeoeo94MwNAmzKgDgCNN9xIADe13pRgGABxvz0CpM8oQ4Ij1LwEQbBufyBAgka9EGG6XSLWbWQMOACA5AxyZKCcEYGcA9s6AvTMQ7wzEOwP1zkC9MzDvDMw7g+SdQXLOgELwBnDPwLldE5A3gHcG0TuD6J0BojeAOgNQ9AYQZwAGbwDvVuE96ZN4G028jabeRlNzBjBvo5l3q0jeRkvOrYK9VxXsvapg71UFe68qGJyNxhG9AZyNxhi9AbyNRuAN4G00760EZm+jsXerEG+jiXerUG+jqXersNuNZtTum+6dkYxu6Wt7fqG7Tej6DHDLRHJhkrLRJOWiSX1MlQ2TlAsTwGyYWC5MYjaaTLDKmojJBOciUzHhXJhwNppwNppILvOOSDbe0Wz6iWbTYy0bTSwbTVLMhkku3tE4wc8f6l4/vBOhE+ycS8dfbHDhyC4+QWqCLp7477/qp7+z9Xz2uKh+7ky+fCyfelcoN//eqoPblG/r1VP1/LGumnuVuyuVjTdBoQSDmgw00xxwKkGoeWwEA7ESNNSoNfJ/",
       "brillig_names": [
-        "public_dispatch"
+        "_check_block_number"
       ]
     },
     {
@@ -3562,7 +3450,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VVbasMwELyLvv2xu9LqkauUUpzECQZjB8cplJC7Vwq2lKRKiiktFPJjvNKMdpgdy0exrpaH7Vvdbrq9WLwcRdOtyqHuWl8dBfJ5bb8r21Duh7IfxIIUu0JU7Tq8Gj4VYlM3lVggwan4iiZtJjRZF9GOcmCn7AiWQPgYjGwcjWhkCzrCycjc4Uh6UoIq6SaX041Sy+lwhXCFfi0E6qc196wxT2vuWWOz1kgnkzX2G2sURP0KKaENnTu43+5AkOtgJIwUixQZGrMTsGDSBFRySXMGLjUnMUm5H0UQgz8Xw5DEOPlYDDqWMT2Olbs0JxdjayHm2IG79ZL+t3z5t/IJ0MQcgzTX0fTFsq+bpt6+Xf3FIDyUykllxPE4ZrjNluL5FD2fYuZT7EyKrzAg83Hj+LUbdhdE6Ym+fC/7ulw2VfAy7B7a1WStL4eP3bQzmb/ru1W1PvRVGEOaQMiKxEJhuKXCHeInzxy1nZeICwm+q+/8CQ==",
+      "debug_symbols": "7VXbasMwDP0XP+fBkixf+itjjLRNSyAkJU0Ho/TfZ5fYaTu3I4wNBn0Jln2OdDhS7KNYV8vD9q1uN91eLF6OoulW5VB3rY+OAvi8t9+VbQj3Q9kPYoGKXSGqdh2Whk+F2NRNJRaA8lR8RaM2EY3WJbTDHNgpO4JJIjwGAztWI9qvtU1wNJRLDqijElCTbnQ53UCaYnIF8gr9WgjQT2vuWWOe1tyzxmatIUeTNfYbaxRgtEaBpoQ2eK7gfrsCylwFQ3KkWMDE0JDtgJUmdcCqySXNGThpTmKmzKEVQQz8XAzLSYyjx2LA6STHry1empMZHpKQjCep8NZL/N/y6W/loySZfkbJAFd6fLDs66apt29Xr5gMH6VyUn2KMR2zvJ0txfMpej7FzKfYmRQfQUDmx40djkTD7oJInujD97Kvy2VTBS/D6aFdRWt9OHzs4kk0f9d3q2p96KvQhqkDYVYICgXhlgp3iO88c9J23kIuSPqqvvIn",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "enqueue_public_function_call_internal"
@@ -3570,23 +3458,135 @@
       "verification_key": "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"
     },
     {
-      "name": "sync_notes",
+      "name": "public_dispatch",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "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": [],
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "ZY5bCoMwEEX3Mt/5MKZSdCtSJOoogZBIHoUSsvdORGioP5e5w+FyEqw4x31SZrMehjGBtosMyhpqKTOYndJa7VP9hqYEFyfvD2lK9UG6AAMXvWgYoFnP+yloY1MaqbU8sxsv+vaiH5z/2K7Lr0z1LZ2Ss8bLZotmqeTC58A/z8PZBdfosBhXspQj71jb0CxNfwE=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "public_dispatch"
+      ]
+    },
+    {
+      "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": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCHQCASoBKBS4IgEkAAS4IgEoAAiUAAABZJQAAAIQoAgABBIBLJwICBAA7DQABAAIoAIBDAgAEKACARAIABigAgEUCAAEoAIBGAgACKACARwIABSgAgEgCAAMmJQAAA1IeAgAEAR4CAAUACjgEBQYkAgAGAAAApSUAAAN7HgIABAknAgUAAQo4BAUGJAIABgAAAMElAAADjR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYLKAABgEUABCcCBQEBJAIABAAAAzsjAAAA9AsoAAGARgAHFgwCCCQCAAcAAAMpIwAAAQ0LKAABgEgACSQCAAkAAAMXIwAAASILKAABgEMACiQCAAoAAAMAIwAAATcLKAABgEcAChYMBgskAgAKAAAC6SMAAAFQCygAAYBEAAgkAgAIAAAC1yMAAAFlJwIBAkknAggCZCcCCgJhJwILAnInAgwCbycCDQJpJwIOAnYnAg8CZScCEAIgJwIRAmwnAhICbicCEwJ0JwIUAnAtCAEVJwIWBBIAEAEWAScDFQQBACgVAhYtDBYXLQ4BFwAoFwIXLQ4SFwAoFwIXLQ4OFwAoFwIXLQ4KFwAoFwIXLQ4RFwAoFwIXLQ4NFwAoFwIXLQ4IFwAoFwIXLQ4QFwAoFwIXLQ4MFwAoFwIXLQ4UFwAoFwIXLQ4PFwAoFwIXLQ4LFwAoFwIXLQ4KFwAoFwIXLQ4TFwAoFwIXLQ4NFwAoFwIXLQ4MFwAoFwIXLQ4SFycCAQEAJwIIBAAKOAEFCiQCAAoAAALOJwILBBMtCAEMJwINBBMAEAENAS0MDA0qAwANBRPmMpnlFxQJACgNAg0AKBUCDicCDwQRLgQADoADLgQADYAELgQAD4AFJQAAA58nAg4EEQA4DQ4NLQ4IDQAoDQINPA0MCy0MAQYjAAAC4C0MCwYjAAAC4C0MBgIjAAAC9wQ4CwgBLQwBAiMAAAL3LQwCCSMAAAMOEjgGAgEtDAEJIwAAAw4tDAkHIwAAAyAtDAYHIwAAAyAtDAcEIwAAAzItDAgEIwAAAzItDAQDIwAAA0QtDAIDIwAAA0QkAgADAAADUSUAAAPlJigAgAQEeAANAAAAgASAAyQAgAMAAAN6KgEAAQX3ofOvpa3UyjwBAQImKgEAAQWeScksjTulvTwBAQImKgEAAQW6OL+KoDMf/zwBAQImAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAAPkLgGACIAGLgKABoAJAQCACAACgAgBAIAJAAKACSMAAAOzJioBAAEFdS4blGTo99s8AQECJi4AGMoYyg==",
+      "debug_symbols": "zVrdbuowDH6XXnNhJ3bs7FWOpolt3YSEYGLsSEfT3v2kjJRCOxi0lnIz0WH3+2nshDSf1XP9+PH6sFi9rN+ruz+f1XL9NN8u1qt09fk1qx43i+Vy8frQ/XcFzR/0skt4f5uvmuv37Xyzre4QvfOzql497z4Tppu8LJZ1unLwNevFk0Tdh5NCaKPFDwQr+7APVmbsBt/PKiT3AyOSA6MglxgFx5lR8HSBEYWYGZFyj9FvPArxiFGTx+62vAA35vFwXpLX5mnQC84JSIYR0Hjeuehcvnd0FE+dE/gFI4GeEuHb8vRGPNXb8qIfyouSR2qMh5EXcMC/4DDHBuf0wjBNDy8P0/T51Oyo58kgAHfZpBwHgwIQPLZJ1E8adguCa80Cd163P/QL6AxI1R0A+tEA1I5L8u4IYGAQe6X8wAg6nWUo2HNL3YdOq0MZCsYIOdghng9OooQPAmPXl29bxvtO1Pou1POdaDQAYxbMXnoAP3TEawAE8rMSDz2AEMcrkAwQoA8QYTRA8Lm/htAD8Ii2FqUhOR5A2gkcfA/AB2MAFmOA4KwBrBWItQKxVqDWCtRaQbRWEI0VEDhrAGsFaK0ArRU4awXOuF2TR2sAawVkrYCsFTBYA5A1gPGyJe0SWAOoMYD1pE/Wkz6pdaGpdaFF60KLbA1gXGgMZA1gXGiM3hrAuNDYelXB1qsKtl5VsDcuNCawBrAuNLJuFWxdaGzdKqy3Eth6K4HFutDEulWodaGpdatQ60KL1q0iji80pbxvevQqZnBLX/Jt5bAJzbu3FwF8MUyK8QSL8cRhMUxCKUw8FMOES2FCxXgywSprIiYTvBeZiMkEq56pmBTjiRTjiRQz72gxtROL6SexlB4rUIonAuV4EkthgqXUjtAEP3+ovX3/TIRMsHMeWv5BeweO9Oo3SE3S1RP//Ve6+jvfLOaPy3p/NPPlY/XUOam5/fdWnxzafNusn+rnj03dHN88nNxsVuwoNEOlRAabUsWEjEGay2YVjcrpW0moCfk/",
+      "brillig_names": [
+        "_check_timestamp"
       ]
     }
   ],
@@ -3611,19 +3611,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"
         },
         {
           "fields": [
@@ -3647,12 +3645,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::check_block_number_parameters"
+                "path": "Router::_check_block_number_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::check_block_number_abi"
+          "path": "Router::_check_block_number_abi"
         },
         {
           "fields": [
@@ -3671,17 +3669,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": [
@@ -3756,7 +3756,7 @@
     },
     "273": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, 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 = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_subarray_variable<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
     "290": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
@@ -3784,11 +3784,11 @@
     },
     "72": {
       "path": "/home/aztec-dev/aztec-packages/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, returns_hash::ReturnsHash},\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        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        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\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        notify_created_nullifier(nullifier);\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        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_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        execution_cache::store(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\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\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    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\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    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\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    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(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    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\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        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter 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        ReturnsHash::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        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\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        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\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_args_hash(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_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\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        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes 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 = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\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        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\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        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes 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 = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\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"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\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        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        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\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 gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\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        notify_created_nullifier(nullifier);\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        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_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        execution_cache::store(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\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\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    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\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    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\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    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(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    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\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        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter 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        ReturnsHash::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        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\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        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\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_args_hash(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_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\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        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes 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 = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\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        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\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        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes 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 = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\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"
     },
     "73": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, Packable, 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_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let 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        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> 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// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> 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"
+      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, Packable, 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_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, args);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "92": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",