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

package/artifacts/ContractInstanceDeployer.json

@@ -4,7 +4,53 @@
   "name": "ContractInstanceDeployer",
   "functions": [
     {
-      "name": "set_update_delay",
+      "name": "get_update_delay",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "11343565365413149907": {
+            "error_kind": "string",
+            "string": "Function get_update_delay can only be called statically"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          }
+        },
+        "parameters": [],
+        "return_type": {
+          "abi_type": {
+            "kind": "integer",
+            "sign": "unsigned",
+            "width": 32
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "get_update_delay"
+      ]
+    },
+    {
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -15,10 +61,19 @@
             "error_kind": "string",
             "string": "msg.sender is not deployed"
           },
+          "11343565365413149907": {
+            "error_kind": "string",
+            "string": "Function get_update_delay can only be called statically"
+          },
           "15573886522241766899": {
             "error_kind": "string",
             "string": "New update delay is too low"
           },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -42,25 +97,47 @@
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
+          },
+          "6504213605561840204": {
+            "error_kind": "string",
+            "string": "New contract class is not registered"
           }
         },
         "parameters": [
           {
-            "name": "new_update_delay",
+            "name": "selector",
             "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 32
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "7V3djhupEn6XuZ4LqigK2FdZHUVJNrsaaZSskuyRjlZ599P2uOmeQBu7gj00cBONYz5XfR80FMVP//vwx6cP//z17unzn1++Pfz2+78Pz18+vv/+9OXz9OnfH48PH74+PT8//fVu/d8P6vAPsDkCvv39/vPh87fv779+f/jNsubHh0+f/5j+9MzTT/z59Pzp4TcA9+M/jxPKS1CWJCinRCiZLREvL9LQS2yhIhFKZAt0CsVEdEIxMQYUw4/HqDAx4KnwVFaFwjZV2GmjToWdZrMufHTHJd0xNIPYsMq4Q9rP7hC5jDvo9OwOev+zO7ihjjfBHfDn3QFj7KkwMOjz7njNs++eAH92R0PWHdZrd44gLwBRsgky69As2NLPIIMCECsJyAlANl2ZFub6mTAmU5mK5+YCsKpMMC5V2s2PHvilHWr18uRZW5U7Dutypy51fF3q+KrU0QrqcqcudaCqtqOB7+2Omd1Bha/cicta4+aR3jIuzmNyuNThl2kVd6BJFEXw89iAuBpZp8IHUbQdokSiEA5RYlHG4xOLYtQQJRbFDFEiUXi0lIQoNESJRXFDlEgUO4bkhChjSI5FcaOjTYgyOtqEKH6IEoni9RAlFmXMkiNRSI0hOSHKGJJjUWAMyQlRxiw5IcoYkmNRcAzJCVHGLDkWRY8hOSHKGJJjUQiGKLEoY0hOiDKG5FgUQ0OUSBTbpyioF1FW/E6i+D6HZAvzfj60Wkei9JlPOSuKUX0OyRlR+hySM6L0OSSfFwX6nCVnRBkdbSwKjiE5IcpoKbEoegzJCVEKDMng3CzKOmZOi2IMcfhpa5fSmPxt58Nve1j9Nh+3ARvSu3bfwL7d97t2/4INa5bPu68Vzya08uqViYT7Ss/HlYziXGmreT6RZrXLnLmywDAXRpU5vgagAEI/pojWxQ/KWHV3ZdzcSxkwNlN6Sl34VOpCq5dOzZpdu+8qVx+1C+5bE7tfufqobXDf+cj9C/bMvKn7Guc+BLWO1fduz+6z2rX6rGpX3+jgvrOR+1C7+mYeEZEURO4j1O0+LcllorjxIO/afb1v9XXt6oepJ5KnyH2qXf0QzKJRcc9zwcLkm7pvlpjHrK5jmN2/YAmxavf3rT7Xrj6HRJDxcc/DtavPIeZhFQXMfMEVEG/q/tQ1BvdNNNviC66MqNr9favva1ffqpA9XaVVgvu1q89L8neVrz65b1XlU3VLIeaxJnYfKk+U5NzftfruxuofTdDtTfibm0B9exP25iY03t4E39wE3b7Rkrm9ids3WnP7RmvczU3w7Rst377RWri9iQKNFnCe4mug3OhiXMhnGLdayktfcMgwz6Am2KvCB+dLLJisnTcc6ePMzU3427PwJViwDSa8ydSyRhccwlfXeCXXJT2HaFsp/ar05D4ope7tv8HZoyl1nvAI3J09oiWkp2nuGntUItoo7FF1GpUINMp6xHBvj5yaS9MUTyQ84to8stVpZH1tHl1wN8idPfKqOo9q0whUbRqBqk+jAqMI0hKNMOU8gpD3JsjmVq7braV02K2l9M83ZAMAdsTV9sMVO6pX7KhedUf1WiJ23gtX6qheqaPntURyczdcO4qbSmwE2Q3XjurVdvS8uqbq1bjA1fz8YiJA5RviCmG5fPoz5gq1t2GzcF1l6tPnD5eXc2jE1W5O5BPZ2oOJkmSrn9UVJVt7+H8NWfRhdWdasnxFNrE6pWw4/KvWB4coVdqFY7dOU6YsQ3gxnOZXZY+SaxqS31vy2gfh9iSnlsbHnUje0ii9D8mNGZLfW/LaJxk3lDxcCjCpr2JpuOM+NydNxxFARprqszFvKM1oNVvSuNFqNqXpOA7LSONhSLMlTceZmPPS6BL7qVqVpuMJSE6amiYKR4+qWjN48aimAOfo0f2z7xjmpoScO+cCHO58A+boAPTkv923/xp27r/Zt/+0c/2J9+2/2bn+Zuft//7pvSv9D6/ZAIsm9v/+e5YK++/27b+tPX7I+V97/5nx39Xef+b837n+Xu3c/8r7T2sX//3r27MSpQHCaAe0utr9MPJFpW24Bt6yeVX2oMwl7/TtVZnKn1kHYanU6bsqA5U/TW+oTOVxjjOLMhzd0geEeuf+31b/o40bn+N6scG3t0HqDjboDjZK1HnYbj+Zg0wrZIXhBRPK60xpH9LPh6tJlsI+1b3QVGR+HJTWcQMvciipGrLhkn1S8WXLE9mmajZDlnuqWbYdkS1xJcl+yJqOyJa4U2w/ZLuqWd8RWd/Q0KN9eG/SRDYxRfANBRXamyVcNNHN02BUU0EFL83Y+wTZlsJFUPNMl6YMRUwWWqrZLNmearbIXpXdkOWOyOqWwsUs2ZbCxRxZ6qlmiyT1dkO2qRxUeMfQRDaeCJiWsovr2BiAE2SbCir00owtxWSbyi6CdYGsS9QsN1WzGbK2p5q1LeWNc2RdS3njLNmmwsUMWd9UuJgj21XNtpQ3zpDlprKLoDGQ9SpBttG8Mfh41sNNZRdRhWaM2ifIthQuYrhgkNAkahabqtkc2Z5qVreUN86SbSlvnCPbVHYxS7alcDFH1vRUs4Z6ItvU0LO8dgdNYiLQUnZxHRvj6v3HC9mmajYcr6FXl2PMZJvKLmoIE4Hj7R8R2ZZqNkfW9VSzrqW8cY6sbylvnCXbUriYIWtVS+FilmxXNdtS3jhHtq3sYrixmLSGBNlG88Zax/es2Kayiya85YJY6QTZloKKHNmmsotZsj3VLPVUs9RTzZqWJgJZsi2Fizmy3NJEIEuWeiLb0kQgR3a/2cUX93c7mBzdd7sd+F/cr3sJGBQt/q/upEw/Kta4ubRldKE0pu+0DrcQTUszS9nU9UYI4Wo0RMB14YOKTtXdhneiItT9KO1FxfFEF1AR644N96Ji3dOJnahY+YnXvahIQ8UCKtadiN+JipVnC/ei4oh0CqhY+e7Jvag4RpcSKtadt9uJipVvJN2LiiOnU0BFOyKdEiqOSKeAipVfNLoXFUdOp4SKI9IpoGLld67uRcWR0/l1Fb0akU4JFUekU0BFqHvP2l5UHJFOCRVHpFNARaSh4q+rqEdbvERF1IuKq1cdzCpWvm+2FhVteCkb2tVbqIKKY3QpoeJ4oguoWPkW4r2oOFYMCqhY+YWte1FxjC4FVKz8itm9qDjaYgkVR6Tzyyqiquq23RePaooajh5VdQ7jxaO7Z4Wn5jz/NGiVKW2dmX/bOl5+O92YNc8Xe2ht7asH5Uj2/kcP3pKs6Yis7qlmdU81Sz3V7P1fXfWWZF1HZO//6qq3JGs7IsvYE9mewkULHZF1tdcsUCCr+TxZa3C+9G76k9aFD1xB1T7yXMOVicN833DEFWofeK7iGhxJc22qXo0LXNlGXLGpes1w7ahedUv9cIYr1T7AluTaUb2ajurV1J6MuYpr8Hri6s4XBgAM6xIArwPQozTcVDPYlObItfJL7WtZQ9JqLovr93mc1pDAjz3qv67itKgzVCyg4lgVLqAi0FCxgIqjLRZQcez0L6LiONN40U5/j0FFZSIV9dgXXELFsS+4gIo04sUSKo69mCVUHJFOARXNGF1KqDhGlwIq8ri9oYSKoy0WUHHc9lVCxSJ3AxEGFZkyuhCwmZ0Hn83ra55/22q3aJ7O66tleUcZvy78wtU2xBXcfILDgo+46iL37FTDNbw5PM21qXrlsC0GV6+i2Vi2UzCXnv6maHeUhpYeb6CwEwwobgZFdgzthCt2VK8aOuLK/XClpoaoDFffD9cil7zvhGuRS372wtX0w9V2VK+2o+fV9hMj0gUnI1bXliW5TpkLHeYXsEp5mGTKI6QlUC0JD63cXRMe55e86YIZUY+qjLaSUAV5qBKrcsF8rEdVRltJqEKjraRUMV2qcn4pgi54xVqPqtBQJaFKn/FKRpULlud7VKXPkTmjih29bUqV0dumVPFDlVgVN9pKQhXfZ37lvCrGJ0dmEzYUGbQxhq/GcPq4YAYjsAMCOyCwk77lMYMR2NECPukDC+cxhAJMMtY1PLdkszquPWMMCjD2ekz6WLjxy9FtjDHmekw6WslgBHacwI6T2PHXY/z1dqxSAgxfjwEQYOz1GMTrMelnIXMFsjVJFYCXoYld9DxYJgkq/frfLMpKUOkXB8C07DWjrDcxiiWo9MXwWRSJUE6AcultklmURA0HIEKJbKESoUiEEimvRcprkRokUoNEaqSzmOBhjg/BYwLlBCif7g3Bh13t4GmJJzTpF5hWMpgRwUjLYC4LMy6GbXTbOdhGv52DWZTBkj03KgdhJuM5hjmUwWTW0uFGBqZVOuLIw2TWQGYtfZMFKhsmccq6BMyJYOnNunmYzJqWWdMya4QiWDomc87PWYLpzwUG7oRiCSo9R8mikk+N82Gq5vwqjwGpbAO6sPcH3SoUm02ke4+yJm7PIh1QljXBNzfhb8/C35wFKLi9iduzSN+QU9REOtItaiIdZZU1cfu64I0+yqpgwmKESqdR/HJayStrYpQR2dpoLS507359WPOESk8yJw8peLjK+QaUF6BQSWxh+v1CWZTdQOGCimoZEUUoka30NCKHIiVCiWwZkS1DWZSO68tstChtAoqi1otM2edrdRgwoDZskVueythDu1HLZM88y+hQ0AOgsxJUeuzOoDaOlU1D6JwWnIa61QqROaGMCJVUflrbWta5DEQoshJU+hLbHCp9kCWLSk+blz3vAC5WI93PA6lwYJ5UbCvdz+dQ6eXILMoKUJSOvmB5gQEYo2IUS1AgspWOrHKojbRgBrWRZcqhrASVnoVmUU6CSt/Hk0WJbPEGrzC7BuMxQlklQhkJymkRyklQXqSGZwHKKCVCpZ8vvaRxp2EnQqWzUVmUk6A2UsY5FEtQGz1ADiVSQ4uUJ5EtEilvRMobkfIbo7kOMds0dVQxiiUoq0UoJ0E5EqG8BLURA5xHbWzAyUQOrIwIJYmIGCS2bLqftzpcQkM/L6FrtzHvDccnvTExxl2P2Zgpn8fw9ZiNRdXzsf/WomoO5SUoLbKlRbZIZItEtozIFovqi2W2RLw2+s4cykpQDkQoyXzXpTd+nO8ttjJyId2FCYy/+in2qK6245EEGHc9RqMAc31P5tPH8jIYgR1DAoygTllghwV20s/r5PKMsRhj3PUYJ7CzkQU7j+FrMVOYAAKMwE56aX9VPymMubZOaeNF8hmMwE56XT6DcddjiK7HGBBg+HoMowBjr8dYgR0r4OMEbccJ6sdd2Q5+TJ/++/7r0/sPz5++TYjDl/98/vj96cvn08fv//t7/ubD16fn56e/3v399cvHT3/88/XTu+cvHw/fPajTP79b5R4t+smXQ0NxCh4dHD8dviRPj+SPHw/fWu8enVKTD5Mf/wc=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "set_update_delay"
+        "public_dispatch"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt/5MKZSdCtSJOoogZBIHoUSsvdORGioP5e5w+FyEqw4x31SZrMehjGBtosMyhpqKTOYndJa7VP9hqYEFyfvD2lK9UG6AAMXvWgYoFnP+yloY1MaqfE+sxsv+vaiH5z/2E7kV6b6lk7JWeNls0WzVHLhc+Cf5+Hsgmt0WIwrWcqRd6xtaJamvw==",
+      "brillig_names": [
+        "sync_notes"
       ]
     },
     {
@@ -175,143 +252,6 @@
         "process_log"
       ]
     },
-    {
-      "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+yloY1MaqfE+sxsv+vaiH5z/2E7kV6b6lk7JWeNls0WzVHLhc+Cf5+Hsgmt0WIwrWcqRd6xtaJamvw==",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "error_types": {
-          "10019982601749771606": {
-            "error_kind": "string",
-            "string": "msg.sender is not deployed"
-          },
-          "11343565365413149907": {
-            "error_kind": "string",
-            "string": "Function get_update_delay can only be called statically"
-          },
-          "15573886522241766899": {
-            "error_kind": "string",
-            "string": "New update delay is too low"
-          },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17595253152434889169": {
-            "error_kind": "string",
-            "string": "offset too large"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6504213605561840204": {
-            "error_kind": "string",
-            "string": "New contract class is not registered"
-          }
-        },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "get_update_delay",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "11343565365413149907": {
-            "error_kind": "string",
-            "string": "Function get_update_delay can only be called statically"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          }
-        },
-        "parameters": [],
-        "return_type": {
-          "abi_type": {
-            "kind": "integer",
-            "sign": "unsigned",
-            "width": 32
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "get_update_delay"
-      ]
-    },
     {
       "name": "deploy",
       "is_unconstrained": false,
@@ -2119,7 +2059,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -2133,7 +2073,7 @@
       "verification_key": "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"
     },
     {
-      "name": "update",
+      "name": "set_update_delay",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -2144,6 +2084,10 @@
             "error_kind": "string",
             "string": "msg.sender is not deployed"
           },
+          "15573886522241766899": {
+            "error_kind": "string",
+            "string": "New update delay is too low"
+          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -2167,46 +2111,102 @@
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
-          },
-          "6504213605561840204": {
-            "error_kind": "string",
-            "string": "New contract class is not registered"
           }
         },
         "parameters": [
           {
-            "name": "new_contract_class_id",
+            "name": "new_update_delay",
             "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 32
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "JgACBAEnAAABBIBQJgAABAMmAgIEASYCAwQAHxgAAwACgE8tCIBPAAEkAAAARSQAAAC+JwIAAQSAUCYCAgQAOg0AAQACJwCAQwAAAysAgEQAAAAAAA6S+filNOhY/Pd32iBuCLDGIOz53rIdE0eYE/YpAIBFAAAAAAEAAAAAJwCARgABACcAgEcEAAMnAIBIAQAAJwCASQQAACcAgEoAAAAnAIBLAQABJwCATAQAAScAgE0AAAEnAIBOBAAEJSQAAAooLAgBAwAAAQIBLQqASAADLAgBAwAAAQIBLQqASgADLAgBAwAAAQIBJgIEAAIsDgQDHgIAAwEeAgAFADI4AAMABQAGIwIABgAAARIkAAAKUTIoAAGAQwAFIwIABQAAASckAAAKYywIAQUmAgYEAwAQAQYBJgMFBAEAKAUCBiwMBgctCoBNAAcAKAcCBywOAwcqAgAGAAAAAAAAAAACAAAAAAAAAAAmAgsEDCwIAAwsDAYNABAACwAkAAAKdSwEAAAsDA0HLAwOCCwMDwksDBAKLA0HBgAoBgIGLA4GBywIAQYAAAECASwOBwYsDQgHACgHAgcsDgcILAgBBwAAAQIBLA4IBywIAQgAAAECASwOCQgsCAEJAAABAgEsDgoJJgIKBAItCIBJAAIiAAAB8Aw4AgoLIwIACwAACbUiAAACAiYCCwQMLAgADCwMBg0sDAcOLAwIDywMCRAAEAALACQAAAsVLAQAACwMDQULKAAFgEoABgsoAAaASAAHIwIABwAAAkokAAALiSwIAQYmAgcEBAAQAQcBJgMGBAEAKAYCBywMBwgtCoBKAAgAKAgCCC0KgEoACAAoCAIILQqASgAILAgBBwAAAQIBLA4GBy0IgEkAAiIAAAKaDSgAAoBHAAYjAgAGAAAJTyIAAAKvLA0HCCwNCAcAKAcCBywOBwgBKAAIgEwACSwNCQcAOAgKCywNCwkBKAAIgEcADCwNDAssCAEIJgIMBAQAEAEMASYDCAQBACgIAgwsDAwNLA4HDQAoDQINLA4JDQAoDQINLA4LDSwNCAkAKAkCCSwOCQgmAgsEDCwIAAwsDAgNLQiATAAOABAACwAkAAALmywEAAAsDA0JJgIMBA0sCAANLAwIDiwMCg8AEAAMACQAAAubLAQAACwMDgsBKAAJgEwACiwNCggBKAALgEwACiwNCgkcDAcLBBwMCwoAHAwKBwQsCAEKAAABAgEsDggKLAgBCwAAAQIBLA4JCywIAQwAAAECASwOBwwuDAAFAA0cDA0PBBwMDw4AAjgNDg8JKAAPgEUADRwMDQ8EHAwPDgAcDA4PBAI4DQ4QCSgAEIBFAA0cDA0RARwMERAAHAwQEQECOA0QEgkoABKARgANHAwNEgQcDBIQABwMEBIEAjgNEBMJKAATgEUADRwMDRMBHAwTEAAcDBATAQI4DRAUCSgAFIBGAA0cDA0UBBwMFBAAHAwQDQQjAgATAAAEcCIAAARfLQiASAACLQiASQAGIgAABH8tCIBLAAIsDA0GIgAABH8jAgARAAAEnSIAAASMLQiASAANLQiASQAQIgAABKwtCIBLAA0sDBIQIgAABKweAgASBRwMEhQEHAwUEwAcDBMSBAw4Eg8TJwIADwQOECMCABMAAAUBIgAABNkjAgANAAAE7yIAAATmLAwPEyIAAAT4LAwQEyIAAAT4LAwTESIAAAUpIwIAAgAABRciAAAFDiwMDxMiAAAFICwMBhMiAAAFICwMExEiAAAFKQA4EhETDjgSExQjAgAUAAAFQCQAAAwdDDgSBxEjAgARAAAFWyIAAAVSLAwJDyIAAAVkLAwIDyIAAAVkLA4PCiwOAQssDhMMHAwTCAAmAgkAICYCEQQSLAgAEiwMBBMsDAkUABAAEQAkAAAMLywEAAAsDBMLBDgOCwkAOAgJCxwMDQgAJgIJAEAmAg4EESwIABEsDAQSLAwJEwAQAA4AJAAADC8sBAAALAwSDQQ4CA0JADgLCQgcDBAJACYCCwBIJgIOBBAsCAAQLAwEESwMCxIAEAAOACQAAAwvLAQAACwMEQ0EOAkNCwA4CAsJHAwCCAAmAgIAaCYCDQQQLAgAECwMBBEsDAISABAADQAkAAAMLywEAAAsDBELBDgICwIAOAkCCBwMBgIAJgIGAHAmAgsEECwIABAsDAQRLAwGEgAQAAsAJAAADC8sBAAALAwRCQQ4AgkEADgIBAIsCAEEJgIGBAQAEAEGASYDBAQBACgEAgYsDAYILA4CCAAoCAIILA4PCAAoCAIILA4BCCwNBAYAKAYCBiwOBgQqAgAGAAAAAAAAAAADAAAAAAAAAAAmAg4EECwIABAsDAYRABAADgAkAAAKdSwEAAAsDBEILAwSCSwMEwssDBQNLA0IBgAoBgIGLA4GCCwIAQYAAAECASwOCAYsDQkIACgIAggsDggJLAgBCAAAAQIBLA4JCCwIAQkAAAECASwOCwksCAELAAABAgEsDg0LLQiASQAHIgAAB1sNKAAHgEcADSMCAA0AAAjcIgAAB3AmAg4EECwIABAsDAYRLAwIEiwMCRMsDAsUABAADgAkAAALFSwEAAAsDBENLA0EBgAoBgIGLA4GBCwIAQQmAgYEBQAQAQYBJgMEBAEAKAQCBiwMBggsDgIIACgIAggsDg8IACgIAggsDgEIACgIAggsDg0ILQiASQAHIgAAB+4NKAAHgE4AAiMCAAIAAAiWIgAACAMsDQoCLA0MBBwMBAUAJgIGBAUmAggEAwA4BggHLAgBBAAQAQcBJgMEBAEAKAQCBywOBgcAKAcCBywOBgcmAgcEAwA4BAcGLAwGBy0KgEQABwAoBwIHLA4DBwAoBwIHLA4CBwAoBwIHLA4BBwAoBwIHLA4FByYCAQQFACgEAgUsDQUDJgIGBAIAOAUGAjYNAAIAAyUcDAcCAAA4BQIGJgIIBAQMOAcICSMCAAkAAAi3JAAADTQAKAQCCAA4CAcJLA0JAi8MAAIABgEoAAeATAACLAwCByIAAAfuIwIADQAACOkiAAAJPiYCDgQDDDgHDhAjAgAQAAAJACQAAA00ACgEAg4AOA4HECwNEA0mAg4EECwIABAsDAYRLAwIEiwMCRMsDAsULAwNFQAQAA4AJAAADUYsBAAAIgAACT4BKAAHgEwADSwMDQciAAAHWywNBwYcDAIIAAA4BQgJLgwACQAIJgILBAMMOAILDCMCAAwAAAl6JAAADTQtBAAGgAMnAIAEBAAEJAAADnEtCIAFAAkAKAkCCwA4CwIMLA4IDCwOCQcBKAACgEwABiwMBgIiAAACmiMCAAsAAAnCIgAAChcmAgwEAgw4AgwNIwIADQAACdkkAAANNAAoBQIMADgMAg0sDQ0LJgIMBA0sCAANLAwGDiwMBw8sDAgQLAwJESwMCxIAEAAMACQAAA1GLAQAACIAAAoXASgAAoBMAAssDAsCIgAAAfAnAIAEBHgADQAAAIAEgAMjAIADAAAKUCkBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFiw4hFpDjtVY7AQECJSkBAAEFWkOb0D7Gskw7AQECJSQAAAooLAgBAiYCAwQEABABAwEmAwIEAQAoAgIDLAwDBC0KgEoABAAoBAIELQqASgAEACgEAgQtCoBKAAQsDQIDACgDAgMsDgMCLAgBAyYCBAQFABABBAEmAwMEAQAoAwIELAwEBS0KgEoABQAoBQIFLQqASgAFACgFAgUtCoBKAAUAKAUCBSwOAQUtCIBIAAQsDAIBLAwDAi0IgEkAAyUkAAAKKCwNBAULKAAFgEgABiMCAAYAAAs3JgIHBAA7CQEHJgIFBAYsCAAGLAwBBywMAggsDAMJLAwECgAQAAUAJAAADv8sBAAALA0BBSwNAgYsDQMHLA4FASwOBgIsDgcDLQqASwAEASgABoBMAAIsDQIBJSkBAAEFAtxuJ4B2Ep07AQECJSQAAAooASgAAoBMAAMOOAIDBCMCAAQAAAu6JAAADB0NMIBHAAMABAsoAASASAADIwIAAwAAC9ckAAAQUiYCBAQDDDgCBAUjAgAFAAAL7iQAAA00ACgBAgQAOAQCBSwNBQMsCAEBJgICBAIAEAECASYDAQQBACgBAgIsDAIELA4DBCUpAQABBUWnynEZQeQVOwEBAiUkAAAKKCwIAQQAAAECAS0KgE0ABCYCBgQCJgIHAQEsCAEFJgIIBCEAEAEIASYDBQQBACgFAggmAgkEIEID8AACAAYACQAHAAgmAgoEIC0EAAiAAy0EAAqABCQAABBkJgICBCAmAgYEIS0IgEwAAyIAAAyiDDgDBgcjAgAHAAAMuSIAAAy0LA0EASUsDQQHBDgHBwgCOAIDBw44AwIJIwIACQAADNkkAAAQ5CYCCgQgDDgHCgsjAgALAAAM8CQAAA00ACgFAgoAOAoHCywNCwkcDAkHAAQ4CAEJBDgHCQoDMIBNAAcACQQ4CQgHADgKBwgsDggEASgAA4BMAAcsDAcDIgAADKIpAQABBeidCf6hES0OOwEBAiUkAAAKKCwNAwYsDQQHCygAB4BIAAgjAgAIAAANbCYCCQQAOwkBCQsoAAaARwAHIwIABwAADf0iAAANgSwNAQYsDQIHLA0DCCwNBAkmAgsEAww4CAsMIwIADAAADagkAAANNC0EAAaAAycAgAQEAAQkAAAOcS0IgAUACgAoCgILADgLCAwsDgUMASgACIBMAAUOOAgFBiMCAAYAAA3oJAAADB0sDgoBLA4HAiwOBQMsDgkEIgAADnAmAgYEBywIAAcsDAEILAwCCSwMAwosDAQLABAABgAkAAAO/ywEAAAsDQEGLA0CBywNBAgtBAAGgAMnAIAEBAAEJAAADnEtCIAFAAkAKAkCCgEoAAqASQALLA4FCywOCQEsDgcCLQqATAADLA4IBCIAAA5wJS0BgAOABgsAgAYAAoAHIwCABwAADowiAAAOly0AgAOABSIAAA7+LQAAAYAFAQAAAYAEAAEBAIADgASACS0AgAOACi0AgAWACwsAgAqACYAMIwCADAAADuotAYAKgAgtAoAIgAsBAIAKAAKACgEAgAsAAoALIgAADrknAYAFBAABAwCABgACgAYiAAAO/iUkAAAKKC0IgEkABSIAAA8PDSgABYBHAAYjAgAGAAAPeiIAAA8kLA0BBSwNAgYsDQMHLA0ECCwIAQkmAgoEBQAQAQoBJgMJBAEAKAYCCiYCCwQEACgJAgw+DwAKAAwsDQkGACgGAgYsDgYJLA4FASwOCQIsDgcDLA4IBCUsDQMGDDgFBgcBKAAFgEwABiMCAAcAAA+YIgAAEEksDQEHLA0CCCwNAwksDQQKJgIMBAQMOAUMDSMCAA0AAA+/JAAADTQAKAgCDAA4DAUNLA0NCyYCDQQDDDgFDQ4jAgAOAAAP5CQAAA00ACgHAg0AOA0FDiwNDgwAOAsMDSYCDAQEDDgFDA4jAgAOAAAQDiQAAA00LQQACIADJwCABAQABSQAAA5xLQiABQALACgLAgwAOAwFDiwODQ4sDgcBLA4LAiwOCQMsDgoEIgAAEEksDAYFIgAADw8pAQABBfQu5YS79CHROwEBAiUnAIAGBAACBwCABIAGgAUtAIAEgAgnAIAJBAAADQCACYAFgAoXAIAKgAojAIAKAAAQ4wMAgAgAAoAIAQCAA4AJgAstAYALgAYBAIADgAiACy0BgAuABwEAgAOACYALLQKAB4ALAQCAA4AIgAstAoAGgAsBAIAJAAKACSIAABCAJSkBAAEFKIaSsEfc/UM7AQECJS0AGMoYyg==",
-      "debug_symbols": "7V3bjhwpEv2XfvYDEUAA8yujlWV7PKOWWrbly0ory/++VFUnmdWQiSuGrCaBl1H3mNMR50BCENx+Pvz18f2Pf94+fvr787eHP/78+fD0+cO774+fP/nffv568/D+6+PT0+M/b5f/+0Gc/gNOnwHfvrz7dPr92/d3X78//GFI0puHj5/+8j86Iv8n/n58+vjwB4D99Z83HuUYKBSKgwLBQvFssXihZqFYtiSLl2TZUjKF0kqLZ5RWZAOK4NebqLAiwOfCilCEwiZV2Mrwl60kvSx8dscm3fFOTO7oBYm0O0q6yR2lbMYdtHJyB5176Y5Oq6MFBHdQb7sDWpvnwkAgt91xkibfnQJ86Q5B1h1yS3fOIMcAmWQT1KQntTQZcz/iFnPuGCVecnCCA0p+59qqALIuR1zQVBhgQRy0TZW2U9MGNzdWKS6fZ7oTfi13ZLp3fz136lIH6lIH6lIHZV3u1KWOrKvtSHtvd/TkDgq8cicua7SdYghDODuPyaFFhr+sFsHJadiOivrYUE1e4GIU8oVPomg3RIlEITVEiUUZn08sisEhSiyKGaJEotjRUhKi0BAlEmVljte5KGNITogyhuRIFCVGR5sQZXS0sSgAQ5RYFD1EiUUZs+RYFBxDckKUMSTHosgxJCdEGbPkWBQ1huSEKGNIjkXRY5acEGUMyQlRxpAci0JyiBKLMobkWBQzhuSEKCOfEovi+hQF5SyK0i9E0fffQFOFKAamvW9opIxE6TOfsi0K9jkkZ0Tpc0jeFkX2OSRnROlzlpwRZXS0sShqDMkJUUZLiUXRY0hOiFJgSAZrJ1GWMXNalMVRGTKLIxqAyb9tXfjbDhZ/m87bgDXpQ7tv5KHdt3Bs97NTXKdx2330C6fT16UUXZmISysgPX234ESmtJE0HVsz0mbOJxkhp+NS/seX55N0fhtaO1R1L1RJdFOrJPqpVeinVvP5tGaoYj+1iv18q/nkTTtUu4mWSGE/VPupVd3Pt0pN1aq2gap+eQMGWdMQVQhe+x8jqq72Bqxnqosj2+kM1ny8WyLOM3mJdOFaewxRjqupfhpXkqtqiCu6KWcrJagrrqncsQm5Y2Hnj1uqVGkbsrZWqkxZP2OckmKSrsqeFIfag5n2FK999G1OcWxpZDyG4i2Nz4dQXMqh+J0Vr31qsaPiBEFxIyJlVMf9bUaZjsf+bWWqT7+8njKjzawoQ6PNrCnTcfyVUcYNZdLKmI5zLxll7FAmrYzteNaRUaam2cHJoaqWB84O1RTXeIfs/RPtGCajCslkSgPJyX0gWu4Y1hf39bHdd4d2H+Sx3T+2+vn7iep2/9jqy2O3/fsn8m50P5zEBrN4rmNy//7bkcq6T4d2X9ceNGTcr73jzLhfe8e57T4dW32yh3bfVN5x+oxMcH/xttPJ/URpgDDIweJdIDwNeFFpE04ImsUjVqeyJ2Fs5X3a6wlT+ffqZyETVSvvKYyr/FN6PWEqj26snoUh97KLdAKO7f6x1Yd91T+b0Lub2Plo09mE2t+E3d3EztPoswmzuwm1f6Pdecp4MlFkWmdMMLEIU9J9gRYhSaEFFT43EJYqDIrMA6cAAsLCBgillsXPytDdlbFTn6pB5/pU3wGHCy2W99ZNfWqRPQOv6H7l6qO0wX0TTbmcqVx9lOFvo40HZOPqdl/i1IeglLH6RaYvr+j+sdV3tasfglH/EZvY/drVD0v9qAS8dB+EMHX7r+QiINGx/0UO6rym/wfXH2vXP9w95v+2Svhfu/4hokUtTOy/1HX7r+fIRysb+6/Ewf0/uP66dv0pXAfoPUn4X7v+YXMVknCx/yTr9p8UBP81Jvy3x/bfHFx/U7v+Zto9imaRZAn+29r1p/ki0MXdpcF/V/nU3QRHfOIh5X/lmZOM/yCOrT+U0F+Ha21Q69xajLY0XzS6uA00mfa0BNPw62FXhU/eYwn1l95TdN+ot0H724A78ChxwYEvEkYDyLVU37ZC3yvEsu1dak+WuADAzN+OFTFribS/DXkHHtLtbyN/K3vehg2L9OhxmRZilZpaiFV6GZ3KZHsSU2cAfj3rqvTZ/xIbZIr5f/GoJkUvHtnaPCqxScWFxTF0CBmPSGC4j1q4nP8uHD/yycrFAqBL7TqRfoXyubR0Nh5upTPtkFUiLMsokcjN/cY78C2R7almS8QrxyGreyLrOiJbYoPSccj2VLMlNm0dh2xDQ490YaeNJxsnrJVqM1xUfiUkQbapoILmZuwSNatbChf9yuhEFgASZFuq2RxZ6qlmS+wFPAxZI3oiq3oi21K4mCNre6rZEinAw5BtKbvoIyiaySYmAi1lF5exMQBFZHVT2UW/wBPIGpUg21S4aGwgaxM1C03VbI5sTzWLLeWNs2RbyhtnyTYVLmbIStUT2Z5qVrWUN86SbWrokRjIujiVqlvKLl7Fxg4SZFuqWRShGaOM88a6qewiBq8V6kTNUlM1myFreqpZ01LeOEfWtpQ3zpJVPZFtKVzMkXU91axrKW+cIUtNZRdRmJksJcg2mjdGHZ9YpqayixjuXFRXjyMEsi2FixLCROD8+sNLsthSzWbJ9lSzsqW8cZZsS3njLNmWwsUc2RIHrI5Dtqea1S3ljbNkm8pBhWdqlZSJiUBL2cVlbCwlJsi2VLPaht0yJOKzeGRaCiqyZFvKLubI2p5q1vZUs66nmnUtTQSyZFsKFzNkjVA9kW0pb5wjCy1NBLJkDxsunt0/7m7Ei/uHHfjP7su6l4BPV4MG/xfPE6Y/FeNXtJ9LG0IbSmP6TePwOI1fmpnLpl69QQivZV3dPI/Pn6Cuuw0fRcW6P6WDqEjjiy6hohoqFlCx7unEQVSs/MTrUVSsewJ0EBVt3Yn4o6g4Ip0CKroR6ZRQcYwuJVQco8u/V9GKuvN2R1Gx7oTgQVSs/HbNo6g4Ip0CKuKIdEqoqIaKBVQcOZ0CKlZ+NepRVByRTgEVK7/M9SgqjkingIp6RDolVKx7z9pRVByRTgEVaUQ6JVQc+cUCKtrRFn9HRZyf+8bFUwfPKjqhhoq/oaKB+dFQKWMVx+hSQMXKd/oeRcUxjy6gYuU7mY+i4pi7lFBxjC4FVKz8itmjqDjaYgEVK78U9ygq1hTpnD2q6uzIxaOaMtlnj+5/psE358kjkCJT2lg9/W1jaf7b6cYsabrYQ0pjrj6UC1nVE1nXEVnTU82anmrW9lSz93+66hXJ3v/pqtcka7ohi0JAT2SpI7LQT7joyeqOyMraaxZUICtpm6zROHntf1TLwmeuO08MLzb0HWwkA0GSOGUASCq5bcOGJxetyzSh04YDPSUi/M/zUyVo9cWh9ASL6ZBb3Kox1Ry5nQ2YvRmYvRmkV+JLGrA7G3B7M3A7M4D07folDZidDaTP6JQ0QDsbwL0ZpJfTChqQezOQe9eBEnsb2LsO1M7dNWi1t4G9OzuSexso0NmFi4Hd4qK3ZJjjk/RTiOa0i4JHMFiVN1VpY6Eqb6gmb1xV2rjaM423TPdITd2HIU0vueL9z77vyVXCJtem6lXbwJVMxBWaqtcM147qFWvPqBbkKmtPlZfk2lG9qo7qVdWeJ7+JK5iZq90u7LMkIXrzP1/n4M/S6Kaawao0Z66Vv0pRyzY6KaayuHzS8LKNzqs4DjsXULHydzSOouLYXvzvVZRCDRULqDjaYgEVYbTFEiqOI+O/ddjZYVBR6EhFHMcuSqg4DpgWULHyB5iPouI4YFpCxRHpFFBxHOorouIYXQqoqMc1gCVUHG2xgIo08osFVCxx3ZXCcBeUUpTRRQFNe68VuGxeX9LkvvG+htLpvL6Yl3eEdsvCF66mIa5gp0PsBlzMtcSZtHq4GrXJtal6pbAtBq+3ECb6GBChA/M/q2h3lBItfd4QvPY/upir7YcrdFSvJe7MOgxX6oerbGqIynB1/XBVqh+uJe4iPwxX3Q9X6qheqaPvlTqKEfMnI6wz21x95kKG+QUsUh46mfIIaQkUs4hS2LsmPLaXvHV+RtSlKqOtJFTJv0zXoyr5+ViXqoy2klBFjraSUkV3qcr2UoRWYqiSUEUNVRKq9BmvZFTJL893qUqfI3NGFRq9bUqV0dumVHFDlVgVM9pKQhXbZ35lWxWy6ZE5bCjSaGIM3Y5ZOS64jbndjhHAwDDsrFzTuo1h2EEGn5UDC5sYiQxMOtalqSXrxXHtCbPyXvM2xtyOWTkW7uaj2xhj9O2YlWhlG8OwYxh2DMeOux1jGXYcg89Kf7CFsQIYGHM7BvB2TPpb2H4FBlfe6gaahyay0fdg05fg5VCELJThoEyypsCYqQsC43SMIg7KChZKsVCWg0pvk8yiOGo4ASwUyxYIFkqxUBzlHSILxVJDstSQLDXSWUxwMMWHp+cLY5TloFa+ShduVjs9ZjWHxEpeYCsfWBbmWLD07twMTIr0zcNXMG1j2ErDz8IsC4bEgqVXRVDYcBpBOErAiAVTPGvpC2OzsPQImIfxrBHPWnobCAoTJnHCJOotfWNqHmZYMMuzZnnWHM+aIw4MMFlv1qcGnmH+xxkG9hllOSgpWahkg/QBw9T7W7d49xxS2QYfok17f3x8ApGJ9NJOWRP7s9ByfxN2dxO0Pwvan4XZn4XZn0U6iVXWBO1tAtMBTFkTu9cFypU+yohgwmCESi9Euvm0khNGxyjDsUUrrcWG7t0tD2tOKFrxUAUPFznfCZWePGdRLFvpKD2LcisonFFxLTvFQnFsyXTaJ4cCZKFYtpBlCymLklF9rdzX4ovqgFIyRlH2+1ocBpxQasWWsvNXGXuoVmpZmY1vWWrF6AGkdhxUeuzOoFaORoIIaUG/DLVYIdLPKMNBpR+h8Wtb8zqXhhjlOKj0skQOlV6YyKLS8995zzuAjdVI9/OgRDgwr0RsK93PZ1GahXIcVDr6gvkNN9BaxCjLQVmWrXRklUURA6VXEjg5lOOgVhKXGRQKFkpzUJJlayUFqcPsGrTDCKWQhTIclNYcFAkWiqUGWQ7KsDRM3xwNck7j+gE/RhEHlV7ay6IUC2UZKFrpAXIojhoEwEKxbKFgoRQLxVJ+ZTSXIWYDr3OMshxU+tL8HEoLFoo4qJXIIYdyHNRKDLAdOZDhRERkgYXi2LLpft7IcAmNkhFmZd6rwoRI6wiTXjLOYBQDY2/HrCwWb8f+a4vF26i1xeIcimULWLaAZQtZtpBlSyILxbKlWLxW+s4cynFQWrJQnPmuS29o2ewt3FpGLqS7MMas5OO2vmLn8HY77mbffHcqGBjFwNzck/n+XTIwDDtIt2MkMDAMO4phJ/29Oj2162V+esKkI50MhmFnJQu2jbG3YwzDjmHYSS9/L+onhTG316lDBuZ2OyD07RgQDMzt3wKgZGBu7w9AKgbG3Y5RDDuKwUcjA8OoH7qxHfzyv/333dfHd++fPn7ziNM//vj04fvj50/Pv37/35fpX95/fXx6evzn7Zevnz98/OvH149vnz5/OP3bg3j+z5+nvbJGCe/LqdO0fvJp5fm30z9qYd9okKdfz/8q3BsL4H3wfvwf",
+      "bytecode": "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",
+      "debug_symbols": "7V3bjhurEv2XeZ4HCooC9q9sHUVJdnY00iiJcjnSUZR/P23PNN0Tqo1dwR4aeInGMctVa0FDUVz6590/H979+Pjm4dO/n7/d/fX3z7vHz+/ffn/4/Gn69PPX/d27rw+Pjw8f36z/+04d/gGyR8C3L28/HT5/+/726/e7vxwZur/78Omf6c9ANP3Evw+PH+7+AvC//nM/oYIE5VCC8kqEktkS8QoiDYPEllYoQolsgeFQhIjPKELSEUXw6z4pjC7458Lo1WLCcYW9jf54a2Fd+OiOZ92xqGZ3LKmMO6Tt7A4ZzLiDFGZ30Nvf3dEb6gQb3YFw2h2w1j0XBgJz2p1g7fzLwQb/uzsGsu6QWbtzBAUBCNkmSJOeM4gc/g6yWgAiJQF5Acjxlelgrp8JYzOVqcjMlQmrygTrudJ+buqwqkujnp4856pyx+u63KlLnVCXOqEqdYyCutypSx2oqu0YoFu7Y2d3tNIv3EnLuoA2hith+WXNDpcm/jLqJSrQlimqIcxjg9ag14UPohg3RElEQT1ESUUZj08qilVDlFQUO0RJRKHRUhhRcIiSiuKHKIkobgzJjChjSE5F8aOjZUQZHS0jShiiJKIEM0RJRRmz5EQUVGNIZkQZQ3IqCowhmRFlzJIZUcaQnIqix5DMiDJmyakoZgzJjChjSE5FQRiipKKMIZkRZQzJqSgWhyiJKK5PUbRZRFnxexYl9DkkO5i3F2pnTCJKn/mUk6JY1eeQnBGlzyE5I0qfQ/JpUaDPWXJGlNHRpqLoMSQzooyWkopixpDMiFJgSAY/n5yBdczMi2ItUvxp55bSmv1tH0/lQIDVb9NxG7BFs2v3Lezb/bBr98/YsObotPtG0WzCqKBemGDcV2Z+yK2iXGlncf5tZ2k5oMX2CM7g7LUzPnN8beq64lG06W/34jzXQRmnbq6Mn3spC9ZlSk+pi8ClLox66tSc3bX7vnL1tfHRfWdT9ytXXxsX3fchcf+MPTOv6r6JB0O1Man6we/ZfVK7Vp9U7epbE933LnEfalff6tl9VJC4r6Fu93FJLiOmjUfTrt03+1bf1K5+nHpqDJi4j7WrT/HRtSrtec5YmHxV9+0S80xheeL+GUuIVbu/b/WpdvUpJoJsSHseql19ijEPqSRgpjOugHhV96euMbpvk9kWnXFlRNXu71v9ULv6TsXsqVKp+7WrT0vyd5Wvfnbfqcqn6g5jzONs6j5UnijJub9r9f2V1T+awOubCFc3oc31TbirmzD6+ibo6ibw+o0W7fVNXL/R2us3WuuvboKu32jp+o3WwfVNFGi0oOcpvgHMjS6kcB6LSFHmRkHv1fzTfupO14UPzpdYMFk7bynRx9urmwjXZxFKsCAXTQSbqWWjfXRIv7jGi12XDBSjbaXMi9KT+6CUurX/Vs8eTalzxiPwN/YIl5Aep7lr6lGJaKOwR9VpVCLQKOsRwa098moujVM8wXhEtXnkqtPIhdo8OuNukBt7FFR1HtWmEajaNAJVn0YFRhGNSzRCmPMIYt4bIZtbuWy3lo5eT3/63+JZANAdcXX9cNUd1avuqF5NR/VaInbeC1fsqF6xo+e1RHJzN1w7iptKbATZDdeO6tV19Lz6puo1voHJrU/3PHPVKjTEdUpwz4XXW8NnrlB7GzYLV5954ZRZXs5htF7t5tT0TLb2YKIk2epndUXJ1h7+X0JWh7i6My1ZviDLrE4pFw//qvXBIeRK+3js1q9e38aXJYgvhjP0ouxRcoND8ltLXvsg3J7k2NL4uBPJWxql9yG5tUPyW0te+yTjipITRMmdSqWhjvvcnDQdRwAZaarPxryiNKPVbEnjR6vZlKbjOCwjTYAhzZY0HWdiTktjSuynalWajicgOWlqmigcPapqzeDJo5oCnKNHt8++6zg3RU25cy5A8c43IEoOQE/+u337b2Dn/tt9+4871x9p3/7bnetvd97+b5/eu9D/+JoNcNqm/t9+z1Jh//2+/Xe1xw85/2vvPzP++9r7z5z/O9c/qJ37X3n/6dzif3h5exZTGiCOdoCrq90PI9/PdLI879VxZF+UPShzzjt9e1Wm8mfWQ1wq9eamykDlT9MrKlN5nOPtogwlt/QBarNz/6+r/9HGlc9xPdmg69tAdQMbeAMbJercQLSBkGmFpHR8wYRavYaFLx1i+vlwNclSOHDdC05F5sdBGZM28CKHkqohGy/ZR5VetjyRbapmM2Spp5ol1xHZEleS7Ies7YhsiTvF9kO2q5oNHZENDQ09JsT3Jk1kmSlCaCioMMEu4aJNbp4Gq5oKKmhpxiEwZFsKF0HNM12cMhQpWWipZrNke6rZIntVdkOWOiJrWgoXs2RbChdzZLGnmi2S1NsN2aZyUPEdQxPZdCJgW8ourmNjAGLINhVUmKUZO0zJNpVdBOcjWc/ULDVVsxmyrqeadS3ljXNkfUt54yzZpsLFDNnQVLiYI9tVzbaUN86Qpaayi2B0JBsUQ7bRvDGEdNZDTWUXtYrNWJvAkG0pXNTxfXyoLVOzuqmazZHtqWZNS3njLNmW8sY5sk1lF7NkWwoXc2RtTzVrsSeyTQ09y2t3tGUmAi1lF9exsV69/3gh21TNxuM1+OJyjJlsU9lFA3EicLz9IyHbUs3myPqeata3lDfOkQ0t5Y2zZFsKFzNknWopXMyS7apmW8ob58i2lV2MNxajMcCQbTRvbEx6z4prKrto41sukJRhyLYUVOTINpVdzJLtqWaxp5rFnmrWtjQRyJJtKVzMkaWWJgJZstgT2ZYmAjmy+80uPrm/28Hk6L7f7cD/5H7dS8CgcPF/dScl/6i4gPMtRC6sflvzd1rHW4impZmlLHe9kYZ4NZrWoNeFDyp6VXcb3omKUPejtBcVxxNdQEVdd2y4FxXrnk7sRMXKT7zuRUUcKhZQse5E/E5UrDxbuBcVR6RTQMXKd0/uRcUxupRQse683U5UrHwj6V5UHDmdAiq6EemUUHFEOgVUrPyi0b2oOHI6JVQckU4BFSu/c3UvKo6czp+rGNSIdEqoOCKdAipC3XvW9qLiiHRKqDginQIqahwq/rmKZrTFc1TUZlFx9aqDWcXK983WoqKLL2XTbvUWqqjiGF1KqDie6AIqVr6FeC8qjhWDAipWfmHrXlQco0sBFSu/YnYvKo62WELFEen8sYpaVXXb7pNHNUUNR4+qOofx5NHNs8JTc55/GozKlPbLuwG9wuW2M74xG5ov9jDGuRcPypHs7Y8evCZZ2xFZ01PNmp5qFnuq2du/uuo1yfqOyN7+1VWvSdZ1RJZ0T2R7ChcddETW116zSkWyWp8m65yap6rOgVoXPnAFVfvIcwlXH18M4zzqhCvUPvBcxDV6zXNtql4RI1drEq66qXrNcO2oXk1L/XCGK9Y+wJbk2lG92o7q1daejLmIa3zb9MQVTxcGQJyjrOnvkIZZ1FQz2JTmyLXyS+1rWUMyai6r1+/zeF5DgjD2qP+5itOizlCxgIpjVbiAioBDxQIqjrZYQMWx07+IiuNM41k7/YOOKiqbqGjGvuASKo59wQVUxBEvllBx7MUsoeKIdAqoaMfoUkLFMboUUJHG7Q0lVBxtsYCK47avEioWuRsIdVSRMKMLAs1MEUIur+8szltdnKUQS/N5fb0s76xPZD/n9XVwDXE1LjYY4xOupsg9O9VwJXWSa1P1im7hSqcLA5ilkwHjkhVNAy093kbHnWDGpM2gyI6hnXDVHdWrgY64Uj9csakhKsM19MO1yCXvO+Fa5JKfvXC1/XB1HdWr6+h5df3EiHjGyYjVJJnlOmUuTJxfwCrlYdmUR0xLaLUkPIzyN014nF7yxjNmRD2qMtoKo4qmoUqqyhnzsR5VGW2FUQVHW+FUsV2qcnopAs94xVqPquBQhVGlz3glo8oZy/M9qtLnyJxRxY3ellNl9LacKmGokqriR1thVAl95ldOq2IDOzLbuKHIapdi6GIM8ccFMxiBHRDYAYEd/pbHDEZgxwj48AcWTmNQCzBsrGvjnhhLkGCsFmDc5Rj+WLgNy9FtnWLs5Rg+WslgBHa8wI6X2AmXY8LldpxSAgxdjgEQYNzlGK0vx/DPQuYK5Gn5hUMBLUMT+eR5cIQSFP/63yzKSVD8iwNgWvaaUS7YFEUSFH8xfBaFIpQXoDy/TTKLkqjhAUQokS2tRCgUoUTKG5HyRqQGitRAkRp8FhMCzPEhBM2gvAAV+N4QQtzVDmF1l6BB8wQzSgazIhgaGcxnYYfpwO+wjW47B9vot3Mwp2UwtufWykOcyQRKYV7LYDJrfLiRgRnFRxx5mMwayKzxN1lo5eIkTjnPwLwIxm/WzcNk1ozMmpFZQy2C8TGZ9yHegurDAgP/jCIJip+jZFHsU+NDnKr5sMpjAJdt0D7u/dF+FYrNJvjeo6yJ67PgA8qyJujqJsL1WYSrswAF1zdxfRb8DTlFTfCRblETfJRV1sT164I2+igXr9ubgqAExadRgoJ5WA7K2RRlRbY2WouP3fs60zuj+Enm5CFGD1c534gKApRWEluaf79QFuU2UHpBJbWstRahRLb4aUQOhUqEEtmyIlsWsyiT1pfdaFHGRhQmrVcTZp8vxBS1YSvuOZ6eytRDt1HL8Zwi9yxrrwU9gPZOguLH7gxq41jZNITGi1AVLWHh05R7QlkRilV+Wtta1rksJCh0EhR/iW0OxR9kyaL4afOy5x3Ap2rw/TxgvMJ1+jO1xffzORS/HJlFOQEK+egLrI4aWqtSFElQILLFR1Y51EZaMIPayDLlUE6C4mehWZSXoPj7eLIokS3a4BVn12CDTlBOiVBWgvJGhPISVBCpEUiAskqJUPzzZZY07jTsJCg+G5VFeQlqI2WcQ5EEtdED5FAiNYxIeRTZQpHyVqS8FSm/MZovd0tMU0eVokiCckaE8hKURxEqSFAbMcBp1MYGnEzkQMqKUJKIiEBiy/H9vDPxBCL+voRu/Ma8Nx6fDNamGH85ZmOmfBpDl2M2FlVPx/5bi6o5VJCgjMiWEdlCkS0U2bIiWySqL5LZEvHa6DtzKCdBeRChJPNdz2/8ON1bbGXkYrpLM5hw8VMctLrYTtAowPjLMUYLMJf3ZIE/lpfBCOxYFGAEdUoCOySwwz+vk8szxukU4y/HeIGdjSzYaQxdipnCBBBgBHb4pf1V/XAYe2md4saL5DMYgR1+XT6D8ZdjEC/HWBBg6HIMaQHGXY5xAjtOwMcL2o4X1I+/sB38mj799+3Xh7fvHj98mxCHL398ev/94fOn54/f//dl/ubd14fHx4ePb758/fz+wz8/vn548/j5/eG7O/X8z99O+Xunw+TLoaF4Bfcejp8OX2LAewzHj4dvXfD3XqnJh8mP/wM=",
       "brillig_names": [
-        "update"
+        "set_update_delay"
       ]
-    }
-  ],
-  "outputs": {
-    "globals": {
-      "storage": [
-        {
-          "fields": [
-            {
-              "name": "contract_name",
+    },
+    {
+      "name": "update",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "error_types": {
+          "10019982601749771606": {
+            "error_kind": "string",
+            "string": "msg.sender is not deployed"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17595253152434889169": {
+            "error_kind": "string",
+            "string": "offset too large"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6504213605561840204": {
+            "error_kind": "string",
+            "string": "New contract class is not registered"
+          }
+        },
+        "parameters": [
+          {
+            "name": "new_contract_class_id",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "update"
+      ]
+    }
+  ],
+  "outputs": {
+    "globals": {
+      "storage": [
+        {
+          "fields": [
+            {
+              "name": "contract_name",
               "value": {
                 "kind": "string",
                 "value": "ContractInstanceDeployer"
@@ -2243,71 +2243,6 @@
     },
     "structs": {
       "events": [
-        {
-          "fields": [
-            {
-              "name": "DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE",
-              "type": {
-                "kind": "field"
-              }
-            },
-            {
-              "name": "address",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
-              }
-            },
-            {
-              "name": "prev_contract_class_id",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-              }
-            },
-            {
-              "name": "new_contract_class_id",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-              }
-            },
-            {
-              "name": "block_of_change",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
-        },
         {
           "fields": [
             {
@@ -2537,9 +2472,149 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::ContractInstanceDeployed"
+        },
+        {
+          "fields": [
+            {
+              "name": "DEPLOYER_CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE",
+              "type": {
+                "kind": "field"
+              }
+            },
+            {
+              "name": "address",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::address::aztec_address::AztecAddress"
+              }
+            },
+            {
+              "name": "prev_contract_class_id",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+              }
+            },
+            {
+              "name": "new_contract_class_id",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+              }
+            },
+            {
+              "name": "block_of_change",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::ContractInstanceUpdated"
         }
       ],
       "functions": [
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "new_contract_class_id",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "ContractInstanceDeployer::update_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::update_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [],
+                "kind": "struct",
+                "path": "ContractInstanceDeployer::get_update_delay_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::get_update_delay_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "new_update_delay",
+                    "type": {
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 32
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "ContractInstanceDeployer::set_update_delay_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "ContractInstanceDeployer::set_update_delay_abi"
+        },
         {
           "fields": [
             {
@@ -2740,81 +2815,6 @@
           ],
           "kind": "struct",
           "path": "ContractInstanceDeployer::deploy_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "new_contract_class_id",
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::contract_class_id::ContractClassId"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "ContractInstanceDeployer::update_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::update_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "new_update_delay",
-                    "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 32
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "ContractInstanceDeployer::set_update_delay_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::set_update_delay_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [],
-                "kind": "struct",
-                "path": "ContractInstanceDeployer::get_update_delay_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "ContractInstanceDeployer::get_update_delay_abi"
         }
       ]
     }
@@ -2906,7 +2906,7 @@
     },
     "271": {
       "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"
     },
     "285": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
@@ -2946,7 +2946,7 @@
     },
     "343": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
-      "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Helper function to find the index of the last element in an array that satisfies a given predicate, counting\n// from the end of the array.  If the element is not found, the function returns N as the index.\n// Useful for finding trailing zeroes in arrays which may have valid empty values.\n// e.g. removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\npub unconstrained fn find_index_hint_from_end<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn validate_trailing_zeroes<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let index = unsafe { find_index_hint_from_end(array, |elem: T| !is_empty(elem)) };\n    let length = if index == N { 0 } else { index + 1 };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid array\");\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_trailing_zeroes(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_trailing_zeroes(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_trailing_zeroes(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(validate_trailing_zeroes(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(validate_trailing_zeroes(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_trailing_zeroes(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(validate_trailing_zeroes(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
+      "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & !is_empty(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let index = find_last_value_index(array);\n    if index == N {\n        0\n    } else {\n        index + 1\n    }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid right padded array\");\n        }\n    }\n    length\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(padded_array_length(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
     "346": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
@@ -2966,11 +2966,11 @@
     },
     "70": {
       "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"
     },
     "71": {
       "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"
     },
     "72": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",