@aztec/protocol-contracts 0.67.0 → 0.67.1-devnet

package/artifacts/FeeJuice.json

@@ -1,29 +1,111 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+b3f4ad661c8c6f88544d714fd5b7b6f58a8ce4ad-x8664",
+  "noir_version": "1.0.0-beta.0+4184522b3ac6c4ce82aadf4911289cdf9fb0dd79-x8664",
   "name": "FeeJuice",
   "functions": [
     {
-      "name": "public_dispatch",
+      "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
             "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
           },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
+      "debug_symbols": "tdfNasQgFAXgd3HtwuvPGPMqpQwmMYMgJpikUELevWaYtkNnWc4mcOXmE8SD3J0Nodtu15jHaWHt287S1Ps1TrlW+8FZV2JK8XZ9Xmbi/Dh1719mn89yWX1ZWaslZyEPrDWi/j3GFOqaaA7+0mm/O6396TTyeOfMaZhsYPIFJluY3MBkh5JJCBxNOFriaIWjNY42OPqCoy2ObnA0Lo2ESyPh0ki4NBIujYRLI+HSSP9Mo1OPznq0L7YF2g3QdjhbCqBNQFsCbQW0NdA2QBuYSwnMpQTmUqJyedTqw5fouxQeg9W45f5pzlo/5/Bn5JrL1IdhK+Ecvn7nrvMuK821vj/ttSAlOSlbN6kbfQE=",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
+    {
+      "name": "check_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
           "15238796416211288225": {
             "error_kind": "string",
             "string": "Balance too low"
           },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -36,10 +118,6 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
           "3219842053230618354": {
             "error_kind": "string",
             "string": "Function check_balance can only be called statically"
@@ -48,10 +126,6 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -59,7 +133,7 @@
         },
         "parameters": [
           {
-            "name": "selector",
+            "name": "fee_limit",
             "type": {
               "kind": "field"
             },
@@ -68,10 +142,10 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "public_dispatch"
+        "check_balance"
       ]
     },
     {
@@ -228,7 +302,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -559,6 +633,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -1357,7 +1452,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -1688,6 +1783,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -1706,8 +1822,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -1723,8 +1839,8 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-35e05665200bf1aecd4d0a3b106088fd-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-41a705e163dc88ea5a4e4c2908443ccd-client-ivc-true"
     },
     {
       "name": "initialize",
@@ -1848,7 +1964,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2179,6 +2295,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -2963,7 +3100,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3294,6 +3431,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -3312,8 +3470,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7VjbjhoxDP2XeZ6H2M7F3l+pqhW3XY2EAHGpVCH+vQklGRayIFO6FSoviAznjA/Hcc7AthlPhpv31272Nl81L9+2zXQ+Gqy7+Syutg3Q/tpqMZil5Wo9WK6bF/Bi2mYyG8e3wZhd27x100nzYg3t2jM0MvEBjex7NARXQZMDOaDJCV5BswR3QLOwFDQBVNAQmLJuNv290dfABn0Gm1S8B39vG7BPY+rGuKcxdWP8nxtjjcvirREoaP+7QvjrFbhaAQRyBfR4pUIgDAd0IBv6CvLAvZV7+OJ6Xxgv++I499RDLyayohg09xAjmMVYutKkeGebpcf33h7vmsp0I7HN440W6GSTITy4fvxy/cGXERexp1OL9RCPR2smEVw7FziU3clyNCxVhwLnoWXszSQjezX15CTEoobkihpByoMuhHBZDTgqc+6PpHPYy6nnlTVFjnXuPzzS0D99qfoSnr5UfeF7+HKvCJR7iPl3EULmwfXDl+u/FIFxMVx202n3/vrh161JL/aTuDYlrmNSnuwvSzdw7A0cdwPHazlxAQlaf3B0fRucfAjPuMAEDFWehFxQ+OwhIICegnoK6SlWT3F6itdTgp7CeoqoKazvPuu7z/rus777rO8+67vP+u6zvvtc776VQglnFFFTxOgpoKegnkJ6ilVS4oou/EsaoBy5IeDp0Wmf4bMPn7j6MVh2g+F0kkI5fbiZjXJGx+X65yJ/klN8sZyPJuPNcpLyvI/yZAyZ1pqoBNLGtNw6Kvm2v4TUIpfoSgzHrefMEN9GsX1n0zVwLZrSss+K7OJ3+QU=",
+      "bytecode": "H4sIAAAAAAAA/+2dBZgTx/+H9ww4pLg7tEVq0buElvYo7q41TnKUQqFQqMvV3d3d3d3d3d3d3ej/8y1Jb1kS+m9vF35vyzzP+yTZncy+38lms5mdnclzlqaeBY5Tr2Dp8zxRkH7MF908yzKP7udFWfI1yrKsSZZlTbMsa55lWRtR5lnWNUu+blmWdc+yrEeWZb3Sy9wpL/1Yln6MhkpisVRpJBWOhstDkWRFIh6KxStKEuFEOJ6IV0US0WgqEUuUJiuSpaFkOBZNhavjyWh1aGlqWlBbVqhOKVIZpGezf+4Z9S4wtxai0OVq9bAk/by3U/u8j+t5s3SezPua63UL0VK0Kqhdnkn5njoI1S2Fe/lYn60L/PNy77NWbrf08xXVcd7/s47b6HVb0U60T9dxoad+s6Uyf2KL5GXZTp7Pn2uef2WFgnLsE4DjMsnvL4t7B6/rl6VDQF+WDukvS6FT+8PlAHc2d6pr2eVV4Uh1qDwaZB20KQimDvz2bA3xLPCvrFCey7OjFWxfjnyn9gBhGdo52VOZLxLxaDDllsSDKbc0xiq3JBlQuamAyi0NptxIKKDPrSKYcqNB+Vax6rckHFA9BHTcCaweSgIqN84qN7DvMW3/Deq4HtTvZiTzT9SdECfcdlJUkEU+iAA6BHQWmlO4rn/XOq2k0+a6enb+554R74K/06bVybW8s6e9pYted7W/paK7q70lcxaeK5X5U9/hlfGN7O0EvEP73ZbRwce2jB4BtWX0WN2WsVxKVVaUV1fHS4Ksgy6QNoIO//G2jJ4FzrLJe5Co6xfbz0ro6wTzYfkds48HgPA6kJjzfYx5XUjMPn4pw+utpJhDdUvh9X2sv+aQg+8GkM8m5ONnQ/lhDPsYc5CeEYdRn1GIZwziGYd4lkA8SyGeCYhnEuLZD+K5IcRzI4hnf4jnxhDPTSCeZRDPARDPTSGeAyGegyCegyGeQyCeQyGewyCewyGeIyCeIyGeoyCeoyGeYyCeYyGe4yCe4yGeEyCeEyGekyCekyGeUyCeUyGe0yCe0yGeMyCem0E8N4d4bgHx3BLiuRXEcybEsxziWQHxrIR4VkE8UxDPaojnLIjn1hDP2RDPbSCecyCecyGe20I850E850M8t4N4LoB4LoR4bg/xXATxXAzx3AHiuSPEcyeI584Qz10gnrtCPHeDeO4O8dwD4rknxLMG4rkXxHNviOc+EM99IZ77QTz3h3geAPE8EOJ5EMTzYIjnIRDPQyGeh0E8D4d4HgHxPBLieRTE82iI5zEQz2MhnsdBPI+HeJ4A8TwR4nkSxPNkiOcpEM9TIZ6nQTxPh3ieAfE8E+J5FsTzbIjnORDPcyGe50E8z4d4XgDxvBDieRHE82KI5yUQz0shnpdBPC+HeF4B8bwS4nkVxPNqiOc1EM9rIZ7XQTyvh3jeAPG8EeJ5E8TzZojnLRDPWyGet0E8b4d43gHxvBPieRfE826I5z0Qz3shnvdBPO+HeD4A8XwQ4vkQxPNhiOcjEM9HIZ6PQTwfh3g+AfF8EuL5FMTzaYjnMxDPZyGez0E8n4d4vgDxfBHi+RLE82WI5ysQz1chnq9BPF+HeL4B8XwT4vkWxPNtiOc7EM93IZ7vQTzfh3h+APH8EOL5EcTzY4jnJxDPTyGen0E8P4d4fgHx/BLi+RXE82uI5zcQz28hnt9BPL+HeP4A8fwR4vkTxPNniOcvEM9fIZ6/QTyXQDx/h3hagQTPPIhnPsSzAOJZCPEsgnjWg3jWh3g2gHgWQzwbQjwbQTwbQzybQDzXgHg2hXg2g3g2h3i2gHi2hHi2gni2hni2gXi2hXi2g3i2h3h2gHh2hHh2gnh2hnh2gXh2hXh2g3h2h3j2gHj2hHiuCfFcC+K5NsSzF8SzN8SzD8SzL8RzHYjnuhDP9SCe60M8N4B4hiCeYYhnBOIZhXjGIJ5xiGcJxLMU4pmAeCYhnv0gnhsG5Jnv8YyGSmKxVGkkFY6Gy0ORZEUiHorFK0oS4UQ4nohXRRLRaCoRS5QmK5KloWQ4Fk2Fq+PJaHW67DwfY97oPxhzf8j+uHFe3esvXF5RkYpVx4L8bAp8jHmTlbQ/huqWwmV5/tVfxwJGzAN8jLl1wX/vuLPpf/BYOxByrB30HzzWDoYca4f4eNzpCTnuhHysv6GQ7+AwiOdwiOcIiOdIiOcoiOdoiOcYiOdYiOc4iOd4iOcEiOdEiOckiOdkiOcUiOdUiOc0iOd0iOcMiOdmEM/NIZ5bQDy3hHhuBfGcCfEsh3hWQDwrIZ5VEM8UxLMa4jkL4rk1xHM2xHMbiOcciOdciOe2EM95EM/5EM/tIJ4LIJ4LIZ7bQzwXQTwXQzx3gHjuCPHcCeK5M8RzF4jnrhDP3SCeu0M894B47gnxrIF47gXx3BviuQ/Ec1+I534Qz/0hngdAPA+EeB4E8TwY4nkIxPNQiOdhEM/DIZ5HQDyPhHgeBfE8GuJ5DMTzWIjncRDP4yGeJ0A8T4R4ngTxPBnieQrE81SI52kQz9MhnmdAPM+EeJ4F8Twb4nkOxPNciOd5EM/zIZ4XQDwvhHheBPG8GOJ5CcTzUojnZRDPyyGeV0A8r4R4XgXxvBrieQ3E81qI53UQz+shnjdAPG+EeN4E8bwZ4nkLxPNWiOdtEM/bIZ53QDzvhHjeBfG8G+J5D8TzXojnfRDP+yGeD0A8H4R4PgTxfBji+QjE81GI52MQz8chnk9APJ+EeD4F8Xwa4vkMxPNZiOdzEM/nIZ4vQDxfhHi+BPF8GeL5CsTzVYjnaxDP1yGeb0A834R4vgXxfBvi+Q7E812I53sQz/chnh9APD+EeH4E8fwY4vkJxPNTiOdnEM/PIZ5fQDy/hHh+BfH8GuL5DcTzW4jndxDP7yGeP0A8f4R4/gTx/Bni+QvE81eI528QzyUQz98hnk4+wzMP4pkP8SyAeBZCPIsgnvUgnvUhng0gnsUQz4YQz0YQz8YQzyYQzzUgnk0hns0gns0hni0gni0hnq0gnq0hnm0gnm0hnu0gnu0hnh0gnh0hnp0gnp0hnl0gnl0hnt0gnt0hnj0gnj0hnmtCPNeCeK4N8ewF8ewN8ewD8ewL8VwH4rkuxHM9iOf6EM8NIJ4hiGcY4hmBeEYhnjGIZxziWQLxLIV4JiCeSYhnP4jnhhDPjSCe/SGeG0M8N4F4lkE8B0A8N4V4DoR4DoJ4DoZ4DoF4DoV4DoN4Dod4joB4joR4joJ4joZ4joF4joV4joN4jod4ToB4ToR4ToJ4ToZ4ToF4ToV4ToN4Tod4zoB4bgbx3BziuQXEc0uI51YQz5kQz3KIZwXEsxLiWQXxTEE8qyGesyCeW0M8Z0M8t4F4zoF4zoV4bgvxnAfxnA/x3A7iuQDiuRDiuT3EcxHEczHEcweI544Qz50gnjtDPHeBeO4K8dwN4rk7xHMPiOeeEM8aiOdeEM+9IZ77QDz3hXjuB/HcH+J5AMTzQIjnQRDPgyGeh0A8D4V4HgbxPBzieQTE80iI51EQz6MhnsdAPI+FeB4H8Twe4nkCxPNEiOdJEM+TIZ6nQDxPhXieBvE8HeJ5BsTzTIjnWRDPsyGe50A8z4V4ngfxPB/ieQHE80KI50UQz4shnpdAPC+FeF4G8bwc4nkFxPNKiOdVEM+rIZ7XQDyvhXheB/G8HuJ5A8TzRojnTRDPmyGet0A8b4V43gbxvB3ieQfE806I510Qz7shnvdAPO+FeN4H8bwf4vkAxPNBiOdDEM+HIZ6PQDwfhXg+BvF8HOL5BMTzSYjnUxDPpyGez0A8n4V4PgfxfB7i+QLE80WI50sQz5chnq9APF+FeL4G8Xwd4vkGxPNNiOdbEM+3IZ7vQDzfhXi+B/F8H+L5AcTzQ4jnRwF55ns8o6GSWCxVGkmFo+HyUCRZkYiHYvGKkkQ4EY4n4lWRRDSaSsQSpcmKZGkoGY5FU+HqeDJanS67l48xf7ySYg7VLYU/yfev/noUMD7nQh/r71PIvl3kY8yfQWKu52PMn0Niru9jzF9AYm7gY8xfQmIu9jHmryAxN/Qx5q8hMTfyMeZvIDE39jHmbyExN/Ex5u8gMa/hY8zfQ2Ju6mPMP0BibuZjzD9CYm7uY8w/QWJu4WPMP0NibuljzL9AYm7lY8y/QmJu7WPMv0FibuNjzEsgMbf1MebfITG38zFmB9IG2N7HmPMgMXfwMeZ8SMwdfYy5ABJzJx9jLoTE3NnHmIsgMXfxMeZ6kJi7+hhzfUjM3XyMuQEk5u4+xlwMibmHjzE3hMTc08eYG0FiXtPHmBtDYl7Lx5ibQGJe28eY1/AxZhX1Rx+f99IB9xXriHXFemJ9sYFtR4RFxOpCxERclIhSkRBJ0U9sKDYS/cXGYpN07APEpmKgGCQGiyFiqBgmhosRYqQYJUaLMWKsGCfGiwliopgkJospYqqYJqaLGWIzsbnYQmwpthIzRbmoEJWiSqREtZglthazxTZijpgrthXzxHyxnVggFortxSKxWOwgdhQ7iZ3FLmJXsZvYXewh9hQ1Yi+xt9hH7Cv2E/uLA8SB4iBxsDhEHCoOE4eLI8SR4ihxtDhGHCuOE8eLE8SJ4iRxsjhFnCpOE6eLM8SZ4ixxtjhHnCvOE+eLC8SF4iJxsbhEXCouE5eLK8SV4ipxtbhGXCuuE9eLG8SN4iZxs7hF3CpuE7eLO8Sd4i5xt7hH3CvuE/eLB8SD4iHxsHhEPCoeE4+LJ8ST4inxtHhGPCueE8+LF8SL4iXxsnhFvCpeE6+LN8Sb4i3xtnhHvCveE++LD8SH4iPxsfhEfCo+E5+LL8SX4ivxtfhGfCu+E9+LH8SP4ifxs/hF/Cp+E0vE78K+ZHkiXxSIQlEk6on6ooEoFg1FI9FYNBFriKaimWguWoiWopVoLdqItqKdaC86iI6ik+gsuoiuopvoLnqInmJNsZZYW/QSvUUf0VesI9YV64n1xQYiJMIiIqIiJuKiRJSKhEiKfmJDsZHoLzYWm4gyMUBsKgaKQWKwGCKGimFiuBghRopRYrQYI8aKcWK8mCAmiklispgipoppYrqYITYTm4stxJZiKzFTlIsKUSmqREpUi1liazFbbCPmiLliWzFPzBfbiQViodheLBKLxQ5iR7GT2FnsInYVu4ndxR5iT1Ej9hJ7i33EvmI/sb84QBwoDhIHi0PEoeIwcbg4QhwpjhJHi2PEseI4cbw4QZwoThIni1PEqeI0cbo4Q5wpzhJni3PEueI8cb64QFwoLhIXi0vEpeIycbm4QlwprhJXi2vEteI6cb24QdwobhI3i1vEreI2cbu4Q9wp7hJ3i3vEveI+cb94QDwoHhIPi0fEo+Ix8bh4QjwpnhJPi2fEs+I58bx4QbwoXhIvi1fEq+I18bp4Q7wp3hJvi3fEu+I98b74QHwoPhIfi0/Ep+Iz8bn4QnwpvhJfi2/Et+I78b34QfwofhI/i1/Er+I3sUT8LuyEIk/kiwJRKIpEPVFfNBDFoqFoJBqLJmIN0VQ0E81FC9FStBKtRRvRVrQT7UUH0VF0Ep1FF9FVdBPdRQ/RU6wp1hJri16it+gj+op1xLpiPbG+2ECERFhERFTERFyUiFKREEnRT2woNhL9xcZiE1EmBohNxUAxSAwWQ8RQMUwMFyPESDFKjBZjxFgxTowXE8REMUlMFlPEVDFNTBczxGZic7GF2FJsJWaKclEhKkWVSIlqMUtsLWaLbcQcYfPV21zwNs+6zWFu84Pb3Ns2r7XNGW3zMdtcxzaPsM3Ra/Pf2tyyNm+rzYlq843aXJ42T6bNQVkjbO5Em5fQ5vyz+fRsrjqbB87mWLP5y2xuMJt3y+a0svmibC4mm+fI5hCy+Xls7hubV8bmbLH5UGyuEZvHw+bIsPknbG4HmzfB5iSw8f5tLH0bp97GgD9T2NjlNi64jblt41nbWNE2DrONcWzjB9vYvDburY0pa+O12lioNs6ojeFp42Pa2JM2rqONmWjjEdpYfzaOno1RZ+O/2dhqNm6ZjQlm423ZWFY2TpSNwXSnsLGDbFweG/PGxpOxsVpsHBQbY8TG77CxMWzcCRvTwcZLsLEI7D5/u4fe7k+3e7/tvmq7Z9nuB7Z7be0+VrtH1O6/tHsb7b5BuyfP7neze8nsPi27B+pNYffu2H0xds+J3c9h57x2H4L18bf+89Y33fpqWz9o68trfVutr6f1fbS+gNY3zvqKWd8p60tkfWusr4n1vbC+CHZt3q5V27Vbu5Zp1/bsWpdd+7FrIXZtwNrKre3Y2lKtbdHa2qztydpirG3C/qvbf1f7L2f/bexcP3/p6YNjfZUt9XVqU/rQYsX/sd769lpfV+v7aX0hrW+g9ZWzvmPWl8r6FllfG+t7Yn0xrG+CXau3a9d2Ldeubdq1Prv2ZdeC7NqIXSuwtnNrS7a2VWtrtLa3bqK76CHsv7v9l7X/dvZfx/rP9xZ9nOVTget58/Rj63cHtF/w8AWD3flar2BdlxzritKPJenH4vRjvlNbX7b9svTrUN1SuNhVrt/lJ0KxkmJn2eSzf7TYVWaQ5RcGU/4ffZwtDaxZtnzHs90CT75s72mSfp7nLJ8nE0cQ+5E+51jA9RTJlF8voM85U29FrroryBJTZvtNnGU/q8z6bI+Os+xn6ni21dAJdB8Oryg2t39m32jmye+tg1xlFf3NslblZ+qua/dn+keemtp1+Z51ha51RZ51RTXLx2i/YV1c+bJ9BzP5+njqJchjclDHAksts/i7t2Wpfo3zZ8rUQYFrWaYuM3XbwJ3fs67Yta6wZtntNEy/LnRtx11WxqPIk793+nXT9GM913sy72+WZfv1PNtfxjvLMm+9FGfJX5wlv+2z3dPP7dzI9p+Qq6xc+32+s3xZTZ3lv+OZ9wb8HY3kOcsfh7zHE/f2M+eAlrYrr5wzYOGsxdum5i3a3n2w9b7ZyRJ0Zl2ea3muH1/vewpc+d2pkVN7wlZYs2z+svTyUB1SaSIUymwz8yUocpatPMez/SJP/nj6dUNXPO54y/6hZ3Vpebg6Wl5dHi+vqopVlrfwlO84tfVo9dQ5/Rx+gptcWSe4AX0B45ny6wdTftYTXHcsmfWZfXhQTW1dDqpZ1imTZ4grz5AceYa68gx15bG0ohNl74+02yPbSd9gz7pCZ3m3zDr3ATnjZAfuli4vS8Nqan3//GFwAj2BTwT8Ryrc0lnxyU/b9HM7wLdPP0/NW7A4tTg1bnHF3NmVQxbPq1w0e/68geVz53oP9u4dyp2KPPm878t2YHe/LvS8LspSbq73e5fl2vnc/oQfkE7p16v6B6Q6/Zz9AxKvZLeQhJOUFhL3+wa58gzKkWewK8/gHHly/RC58+T6IXLnGebKMyxHnuGuPMNz5BnhyjMiR56Rrjwjc+QZ5cozKkee0a48o3PkGePKMyZHnrGuPGNz5BnnyjMuR57xrjzjc+SZ4MozIUeeia48E3PkmeTKMylHnsmuPJNz5JniyjMlR56prjxTc+SZ5sozLUee6a4803PkmeHKM8OTJ+BWiYBbWsOJFbXYZbZdFMy2k3me7TkOq0UwW8tYnmddYc3ycfxVy1g/V75s+5alYE984xUB/36FV91+t7R1xb09x+Hvd360yHr3u1x/SjKX5YI99i09BwxqH7f0b2iRHZR+/b/cIts//TzTIjszk98J9Hse9v6OZxpCvN+1fI9PQI0+f155qecsW3feOshsP1vjSV6Ox0xZ3nWZbTV0gj2eryi2wix13cyT31sHucqq9zfLWpWfqbuu63tiq58lf7arENmO9fU96wpd67xX7dzH+kyduI/1AR9jV/jblpcl3szyBlnyZ9uPmjrL128DT2zFwcQWWdFn38C1zcz2G7uWV6UqFs8aNX+W40kFnnrI1Fs7Vx7355XvLL/v189RluN57S2TfAEnlX69qtvfMr2b4BdwYiur/S3I+smUGUD5Wdvfsp0v/1X7m61f0YUXO140Ti8LuK0htirPty3OzDmsxdsr/Xze/EWzq3eemFo0eva8CakdUgsXza6Ym5o4uyo1uLo6Vblo4PzF8xalFjqelO1wl225hUc4vLVKv17Vh7d/SQfMOLwDZmR1B8y/TiuhA2Z4dQfMf153K4otW7PX6g6Ytev+hR0w46ub+2rz52ruW90BM71tJ9Dv6OoOmH8n/Zs6YP4fYKDJFSBSAgA=",
+      "debug_symbols": "7VjbjtowEP2XPOfBc7E95leqasVtV5EQIC6VKsS/16HYYcEBDaVbofKCcDgnczjj8Qnsqsl0tP14a+bvi3U1+LarZovxcNMs5nG1q4AO19bL4bxdrjfD1aYagAumrqbzSXzrjdnX1Xszm1YDNrKvL9AoJEc0iuvQYF0BTRbCEU024A00OLZZimPHGY/CJbwXSnAx3d2xeHODLoGNt6fg73UF/LKmzxr7sqbPGvfn1rCx9ohmEyCjgxwq+L9eQYoVIECqgA5vVPCE/oj2xL6rgE/d3fAIZ2znjOB1Z6ykb+qgEwPR0KgGzSPUBExqmG70Kd6Zk/b4/sT5UBxxJOE048hAZ/sM4cn145fr9y7v/BD4fHCxnObxfE0kgltHg/i8PSWcTEvRIS9pbgU7M8EfhgXLAUqIWQ2FG2oCUjqoAiFcVwOW8qC7E+lAv8elnFpssh629r881tC9nOlxxr+c6XFGHuHMw6IwPELNv4sSMk+uH75c/7UojIvRqpnNmo+3Tz93TfvCPbFtcmzHxDzfYEz3kPgekr2H5NSkuIIWW36KtF0vbPicpHGFLdIXicGnkkEuHgk86Cmop5CewnqK1VOcnuL1FNFTgpoi+u6Lvvui777ouy/67ou++6Lvvui7L+Xuc8gUf0EJakowegroKainkJ7CSkpc0ZU/Tz3kQ9d7vDg7+ZVBXQbF5Y/hqhmOZtM2oNtPt/Nxyuu43Pxcpk9Soi9Xi/F0sl1N22zvYr01h0zNJkqBdnuy1JZyzB0uIdUoOcBahpXaSWIEV0e1XX/ba2BrNLlvfUX28bv8Ag==",
       "brillig_names": [
         "pack_arguments_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -3321,11 +3479,11 @@
         "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "pack_arguments_oracle_wrapper"
       ],
-      "verification_key": "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",
-      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-0bd3dd2a03004ee692247c75fe17f898-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-cb1d6ce3cc8513ad58244ad545bb40d7-client-ivc-true"
     },
     {
-      "name": "check_balance",
+      "name": "balance_of_public",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
@@ -3333,10 +3491,6 @@
       ],
       "abi": {
         "error_types": {
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -3349,14 +3503,14 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -3364,51 +3518,49 @@
         },
         "parameters": [
           {
-            "name": "fee_limit",
+            "name": "owner",
             "type": {
-              "kind": "field"
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
             },
             "visibility": "private"
           }
         ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "check_balance"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
+        "return_type": {
+          "abi_type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
       },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndJLCoMwEAbgu8zahXmp8SpSJGqUQEgkxkIR794ottjiJm4GZsg3Wcy/QCebeaiV6e0EZbWAtq3wyprQLWsCjVNaq6E+jyHdCkL7+2kUZmsnL5yHkuIEpOmgZGnQvdIyzFKyPhJAOBaQWEBjAYsE+PIHTnh2EE4x+SKOdsNumOyGyW+YIt6Qy8NzWrCPYSn9MWvonsIp0Wh55KqfTXuKmX+N8i9xo7Ot7GYnt+ydYhdqhfIE47A2rH4D",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "balance_of_public"
       ]
     },
     {
-      "name": "balance_of_public",
+      "name": "_increase_public_balance",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "view"
+        "internal"
       ],
       "abi": {
         "error_types": {
-          "16761564377371454734": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
@@ -3424,10 +3576,6 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -3435,7 +3583,7 @@
         },
         "parameters": [
           {
-            "name": "owner",
+            "name": "to",
             "type": {
               "fields": [
                 {
@@ -3449,186 +3597,129 @@
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
             },
             "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "field"
-          },
-          "visibility": "public"
-        }
+        "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "balance_of_public"
+        "_increase_public_balance"
       ]
     },
     {
-      "name": "set_portal",
+      "name": "sync_notes",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
           }
         },
-        "parameters": [
-          {
-            "name": "portal_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
-            },
-            "visibility": "private"
-          }
-        ],
+        "parameters": [],
         "return_type": null
       },
-      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
-      "debug_symbols": "7ZfbioNADIbfZa69SDLH9FWWZbGtLYJosXZhKX33dcRDa2UHpF0K9UYc+TKZ/zdRchbbZH3af6X5rjiK1cdZZMUmrtIir1fnSyTWZZpl6f7r+rEAfzHc8MdDnPvlsYrLSqzQWopEkm/9LXO9wy7NErFSIC/RHU3obEsTIfU0KpygLaFpaUvS9rTRUzBAt7UFZf6GEZyV3bGB4Qb/jIRV76PVwf9rBey1agppdR3rN+s2tjzBOqdaloEDrDLdiRXLgeXGEr1YMrIEiRZP7jyxiydjT+TSO3eeqOAn1iHeeNJE6TlRelYu7eZEGTkrarprHA1RWgcqpD5w5zeaF/65ojVvJNbRA8QaDb1Yo2/ENjns83OwfnoOAnhADkduoFWoMIzpv5PGyUBhKNO9aqtRhQqDXX9sBJKjwiCwbyQW5SPEct9pjPyiYi/16jsu03idJe38uDvlm6txsvo5JKPJ8lAWm2R7KhM/Yw7jJfp+kDKSzncg+gVHCuscdZ5f",
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgEAbgd5lzh3S1sleJJawsBNEwW1iid19d2qVduuhlYAa/8TD/BoPo1qmVejQL1M0GyvTcSaN9t+0ZdFYqJaf2PIY8FITe75eZ69AujlsHNcEZCD1ATXOvR6mEn+XVfs8A4VhwiwUkFtBIgC9/YASxgzBCii9CfkFANAUVKahMQVUCul1en9G8+iCKy1+0+/bBreSdEke6xlX3p7C55yz+cjdb04thtSIk8BQ+XxtUZhj7tX71Cw==",
       "brillig_names": [
-        "set_portal"
+        "sync_notes"
       ]
     },
     {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "name": "public_dispatch",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "custom_attributes": [
+        "public"
+      ],
       "abi": {
         "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
           "16541607464495309456": {
             "error_kind": "fmtstring",
             "item_types": [],
             "length": 16
           },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
           },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
+          "2236649814169388962": {
+            "error_kind": "string",
+            "string": "PublicImmutable already initialized"
           },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
           },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
           },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
           {
-            "name": "serialized_note",
+            "name": "selector",
             "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
+        "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfNasQgFAXgd3HtwuvPGPMqpQwmMYMgJpikUELevWaYtkNnWc4mcOXmE8SD3J0Nodtu15jHaWHt287S1Ps1TrlW+8FZV2JK8XZ9Xmbi/Dh1719mn89yWX1ZWaslZyEPrDWi/j3GFOqaUAd/6bTfndb+dBp5vHPmNEw2MPkCky1MbmCyQ8kkBI4mHC1xtMLRGkcbHH3B0RZHNzgal0bCpZFwaSRcGgmXRsKlkXBppH+m0alHZz3aF9sC7QZoO5wtBdAmoC2BtgLaGmgboA3MpQTmUgJzKVG5PGr14Uv0XQqPwWrccv80Z62fc/gzcs1l6sOwlXAOX79z13mXleZa35/2WpCSnJStm9SNvgA=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
+        "public_dispatch"
       ]
     },
     {
-      "name": "_increase_public_balance",
+      "name": "set_portal",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal"
+        "public"
       ],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "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": {
+          "2236649814169388962": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "PublicImmutable already initialized"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -3637,7 +3728,7 @@
         },
         "parameters": [
           {
-            "name": "to",
+            "name": "portal_address",
             "type": {
               "fields": [
                 {
@@ -3648,24 +3739,17 @@
                 }
               ],
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "field"
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
+      "debug_symbols": "7ZfdaoNAEIXfZa+92Jn9mZm8SinBJCYIYoIxhRLy7lWJG2OlUtuUQrwJWfnWOXOc2WXOapOsTrtlmm/3R7V4Oatsv47LdJ9Xq/MlUqsizbJ0t+w+Vrr+8dLwx0Oc18tjGRelWpDWFKkk39R/ra/esE2zRC3EXqJPMGgmc6VBix7DibClSSTAVvMAjcCtEkTAQJMZgAnBt7LRUFfHa6TIPk2qrIdSfagcDUGOw69tIc0tayGg6GmAZbZXVrSMsNa3gq2YwII0jrjZkXtHAHG2pG8JzZb0LDFz4/QtsaOnKwPcWdLsclN2uUmxHE/Z5c2kXfTn1yrjTZFzI8VXmdEqAf+zaxXIP0+uPHw9fE+Pdzro8a6rpwlBDw8h7tEhUA+2KFnffmZyYMeKQjgIAo3mV4uCkW+0HSkK78Pp69n0igI1PU+uYP57rhIOEgGZnuulWr3FRRqvsuQ6MG5P+bozP5bvh6Q3Sh6K/TrZnIqkHipv8yTUzWBMZLjuPqgXElmoYlRxPgA=",
       "brillig_names": [
-        "_increase_public_balance"
+        "set_portal"
       ]
     }
   ],
@@ -3735,7 +3819,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3746,23 +3830,17 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "FeeJuice::set_portal_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::set_portal_abi"
         },
         {
           "fields": [
@@ -3800,6 +3878,27 @@
           "kind": "struct",
           "path": "FeeJuice::initialize_abi"
         },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "fee_limit",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "FeeJuice::check_balance_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "FeeJuice::check_balance_abi"
+        },
         {
           "fields": [
             {
@@ -3855,7 +3954,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -3866,38 +3965,23 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::set_portal_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
               }
-            }
-          ],
-          "kind": "struct",
-          "path": "FeeJuice::set_portal_abi"
-        },
-        {
-          "fields": [
+            },
             {
-              "name": "parameters",
+              "name": "return_type",
               "type": {
-                "fields": [
-                  {
-                    "name": "fee_limit",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -3967,115 +4051,115 @@
       "path": "std/uint128.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Shl, Shr, Sub};\n\nglobal pow64: Field = 18446744073709551616; //2^64;\nglobal pow63: Field = 9223372036854775808; // 2^63;\npub struct U128 {\n    pub(crate) lo: Field,\n    pub(crate) hi: Field,\n}\n\nimpl U128 {\n\n    pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {\n        // in order to handle multiplication, we need to represent the product of two u64 without overflow\n        assert(crate::field::modulus_num_bits() as u32 > 128);\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {\n        U128::from_u64s_le(lo, hi)\n    }\n\n    pub fn zero() -> U128 {\n        U128 { lo: 0, hi: 0 }\n    }\n\n    pub fn one() -> U128 {\n        U128 { lo: 1, hi: 0 }\n    }\n    pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {\n        let mut lo = 0;\n        let mut base = 1;\n        for i in 0..8 {\n            lo += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        let mut hi = 0;\n        base = 1;\n        for i in 8..16 {\n            hi += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        U128 { lo, hi }\n    }\n\n    pub fn to_be_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_be_bytes();\n        let hi: [u8; 8] = self.hi.to_be_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = hi[i];\n            bytes[i + 8] = lo[i];\n        }\n        bytes\n    }\n\n    pub fn to_le_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_le_bytes();\n        let hi: [u8; 8] = self.hi.to_le_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = lo[i];\n            bytes[i + 8] = hi[i];\n        }\n        bytes\n    }\n\n    pub fn from_hex<let N: u32>(hex: str<N>) -> U128 {\n        let N = N as u32;\n        let bytes = hex.as_bytes();\n        // string must starts with \"0x\"\n        assert((bytes[0] == 48) & (bytes[1] == 120), \"Invalid hexadecimal string\");\n        assert(N < 35, \"Input does not fit into a U128\");\n\n        let mut lo = 0;\n        let mut hi = 0;\n        let mut base = 1;\n        if N <= 18 {\n            for i in 0..N - 2 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n        } else {\n            for i in 0..16 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n            base = 1;\n            for i in 17..N - 1 {\n                hi += U128::decode_ascii(bytes[N - i]) * base;\n                base = base * 16;\n            }\n        }\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    unconstrained fn uconstrained_check_is_upper_ascii(ascii: u8) -> bool {\n        ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'\n    }\n\n    pub(crate) fn decode_ascii(ascii: u8) -> Field {\n        (\n            if ascii < 58 {\n                ascii - 48\n            } else {\n                let ascii =\n                    ascii + 32 * (unsafe { U128::uconstrained_check_is_upper_ascii(ascii) as u8 });\n                assert(ascii >= 97); // enforce >= 'a'\n                assert(ascii <= 102); // enforce <= 'f'\n                ascii - 87\n            }\n        ) as Field\n    }\n\n    // TODO: Replace with a faster version.\n    // A circuit that uses this function can be slow to compute\n    // (we're doing up to 127 calls to compute the quotient)\n    unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {\n        if b == U128::zero() {\n            // Return 0,0 to avoid eternal loop\n            (U128::zero(), U128::zero())\n        } else if self < b {\n            (U128::zero(), self)\n        } else if self == b {\n            (U128::one(), U128::zero())\n        } else {\n            let (q, r) = if b.hi as u64 >= pow63 as u64 {\n                // The result of multiplication by 2 would overflow\n                (U128::zero(), self)\n            } else {\n                self.unconstrained_div(b * U128::from_u64s_le(2, 0))\n            };\n            let q_mul_2 = q * U128::from_u64s_le(2, 0);\n            if r < b {\n                (q_mul_2, r)\n            } else {\n                (q_mul_2 + U128::one(), r - b)\n            }\n        }\n    }\n\n    pub fn from_integer<T>(i: T) -> U128 {\n        let f = crate::as_field(i);\n        // Reject values which would overflow a u128\n        f.assert_max_bit_size::<128>();\n        let lo = f as u64 as Field;\n        let hi = (f - lo) / pow64;\n        U128 { lo, hi }\n    }\n\n    pub fn to_integer<T>(self) -> T {\n        crate::from_field(self.lo + self.hi * pow64)\n    }\n\n    fn wrapping_mul(self: Self, b: U128) -> U128 {\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.lo * b.hi + self.hi * b.lo + carry;\n        let hi = high as u64 as Field;\n        U128 { lo, hi }\n    }\n}\n\nimpl Add for U128 {\n    fn add(self: Self, b: U128) -> U128 {\n        let low = self.lo + b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.hi + b.hi + carry;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to add with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Sub for U128 {\n    fn sub(self: Self, b: U128) -> U128 {\n        let low = pow64 + self.lo - b.lo;\n        let lo = low as u64 as Field;\n        let borrow = (low == lo) as Field;\n        let high = self.hi - b.hi - borrow;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to subtract with underflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Mul for U128 {\n    fn mul(self: Self, b: U128) -> U128 {\n        assert(self.hi * b.hi == 0, \"attempt to multiply with overflow\");\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = if crate::field::modulus_num_bits() as u32 > 196 {\n            (self.lo + self.hi) * (b.lo + b.hi) - low + carry\n        } else {\n            self.lo * b.hi + self.hi * b.lo + carry\n        };\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to multiply with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Div for U128 {\n    fn div(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n            q\n        }\n    }\n}\n\nimpl Rem for U128 {\n    fn rem(self: Self, b: U128) -> U128 {\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n\n            r\n        }\n    }\n}\n\nimpl Eq for U128 {\n    fn eq(self: Self, b: U128) -> bool {\n        (self.lo == b.lo) & (self.hi == b.hi)\n    }\n}\n\nimpl Ord for U128 {\n    fn cmp(self, other: Self) -> Ordering {\n        let hi_ordering = (self.hi as u64).cmp((other.hi as u64));\n        let lo_ordering = (self.lo as u64).cmp((other.lo as u64));\n\n        if hi_ordering == Ordering::equal() {\n            lo_ordering\n        } else {\n            hi_ordering\n        }\n    }\n}\n\nimpl Not for U128 {\n    fn not(self) -> U128 {\n        U128 { lo: (!(self.lo as u64)) as Field, hi: (!(self.hi as u64)) as Field }\n    }\n}\n\nimpl BitOr for U128 {\n    fn bitor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) | (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) | (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitAnd for U128 {\n    fn bitand(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) & (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) & (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitXor for U128 {\n    fn bitxor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) ^ (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl Shl for U128 {\n    fn shl(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift left with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self.wrapping_mul(U128::from_integer(y))\n    }\n}\n\nimpl Shr for U128 {\n    fn shr(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift right with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self / U128::from_integer(y)\n    }\n}\n\nmod tests {\n    use crate::uint128::{pow63, pow64, U128};\n\n    #[test]\n    fn test_not(lo: u64, hi: u64) {\n        let num = U128::from_u64s_le(lo, hi);\n        let not_num = num.not();\n\n        assert_eq(not_num.hi, (hi.not() as Field));\n        assert_eq(not_num.lo, (lo.not() as Field));\n\n        let not_not_num = not_num.not();\n        assert_eq(num, not_not_num);\n    }\n    #[test]\n    fn test_construction() {\n        // Check little-endian u64 is inversed with big-endian u64 construction\n        let a = U128::from_u64s_le(2, 1);\n        let b = U128::from_u64s_be(1, 2);\n        assert_eq(a, b);\n        // Check byte construction is equivalent\n        let c = U128::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);\n        let d = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        assert_eq(c, d);\n    }\n    #[test]\n    fn test_byte_decomposition() {\n        let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        // Get big-endian and little-endian byte decompostions\n        let le_bytes_a = a.to_le_bytes();\n        let be_bytes_a = a.to_be_bytes();\n\n        // Check equivalence\n        for i in 0..16 {\n            assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);\n        }\n        // Reconstruct U128 from byte decomposition\n        let b = U128::from_le_bytes(le_bytes_a);\n        // Check that it's the same element\n        assert_eq(a, b);\n    }\n    #[test]\n    fn test_hex_constuction() {\n        let a = U128::from_u64s_le(0x1, 0x2);\n        let b = U128::from_hex(\"0x20000000000000001\");\n        assert_eq(a, b);\n\n        let c = U128::from_hex(\"0xffffffffffffffffffffffffffffffff\");\n        let d = U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);\n        assert_eq(c, d);\n\n        let e = U128::from_hex(\"0x00000000000000000000000000000000\");\n        let f = U128::from_u64s_le(0, 0);\n        assert_eq(e, f);\n    }\n\n    // Ascii decode tests\n\n    #[test]\n    fn test_ascii_decode_correct_range() {\n        // '0'..'9' range\n        for i in 0..10 {\n            let decoded = U128::decode_ascii(48 + i);\n            assert_eq(decoded, i as Field);\n        }\n        // 'A'..'F' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(65 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n        // 'a'..'f' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(97 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_0() {\n        crate::println(U128::decode_ascii(0));\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_1() {\n        crate::println(U128::decode_ascii(47));\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_0() {\n        let _ = U128::decode_ascii(58);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_1() {\n        let _ = U128::decode_ascii(64);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_0() {\n        let _ = U128::decode_ascii(71);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_1() {\n        let _ = U128::decode_ascii(96);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_greater_than_102_fails() {\n        let _ = U128::decode_ascii(103);\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_regression() {\n        // This code will actually fail because of ascii_decode,\n        // but in the past it was possible to create a value > (1<<128)\n        let a = U128::from_hex(\"0x~fffffffffffffffffffffffffffffff\");\n        let b: Field = a.to_integer();\n        let c: [u8; 17] = b.to_le_bytes();\n        assert(c[16] != 0);\n    }\n\n    #[test]\n    fn test_unconstrained_div() {\n        // Test the potential overflow case\n        let a = U128::from_u64s_le(0x0, 0xffffffffffffffff);\n        let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);\n        let c = U128::one();\n        let d = U128::from_u64s_le(0x0, 0x1);\n        unsafe {\n            let (q, r) = a.unconstrained_div(b);\n            assert_eq(q, c);\n            assert_eq(r, d);\n        }\n\n        let a = U128::from_u64s_le(2, 0);\n        let b = U128::one();\n        // Check the case where a is a multiple of b\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (a, U128::zero()));\n        }\n\n        // Check where b is a multiple of a\n        unsafe {\n            let (c, d) = b.unconstrained_div(a);\n            assert_eq((c, d), (U128::zero(), b));\n        }\n\n        // Dividing by zero returns 0,0\n        let a = U128::from_u64s_le(0x1, 0x0);\n        let b = U128::zero();\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::zero(), U128::zero()));\n        }\n        // Dividing 1<<127 by 1<<127 (special case)\n        let a = U128::from_u64s_le(0x0, pow63 as u64);\n        let b = U128::from_u64s_le(0x0, pow63 as u64);\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::one(), U128::zero()));\n        }\n    }\n\n    #[test]\n    fn integer_conversions() {\n        // Maximum\n        let start: Field = 0xffffffffffffffffffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Minimum\n        let start: Field = 0x0;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Low limb\n        let start: Field = 0xffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // High limb\n        let start: Field = 0xffffffffffffffff0000000000000000;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn integer_conversions_fuzz(lo: u64, hi: u64) {\n        let start: Field = (lo as Field) + pow64 * (hi as Field);\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn test_wrapping_mul() {\n        // 1*0==0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::one()));\n\n        // 0*1==0\n        assert_eq(U128::zero(), U128::one().wrapping_mul(U128::zero()));\n\n        // 1*1==1\n        assert_eq(U128::one(), U128::one().wrapping_mul(U128::one()));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::zero()));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::from_u64s_le(0, 1).wrapping_mul(U128::one()));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::one().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));\n        // -1 * -1 == 1\n        assert_eq(\n            U128::one(),\n            U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(\n                U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff),\n            ),\n        );\n    }\n}\n"
     },
-    "65": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
-      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Deserialize, Empty, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_unencrypted_log(message: [Field]) {\n    emit_unencrypted_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
-    },
     "66": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\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\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
+    },
+    "73": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
+      "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_block_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
     },
-    "69": {
+    "74": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
+      "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
+    },
+    "85": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
+      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
+    },
+    "92": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::arguments::pack_arguments;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let unpacked: T = returns.unpack_into();\n        unpacked\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        pack_arguments(self.args);\n        let returns = context.call_private_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.unpack_into()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        pack_arguments(self.args);\n        context\n            .call_private_function_with_packed_args(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        pack_arguments(self.args);\n        context.call_public_function_with_packed_args(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
-    "82": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
-      "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
+    "94": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
+      "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Deserialize, Empty, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_unencrypted_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_unencrypted_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Serialize<N>,\n    {\n        self.raw_storage_write(storage_slot, value.serialize());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_unencrypted_log(message: [Field]) {\n    emit_unencrypted_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_unencrypted_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
+    },
+    "98": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "87": {
+    "137": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "89": {
+    "141": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use crate::utils::array;\nuse dep::protocol_types::{address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT};\n\n/// Returns the leaf index and sibling path of an entry in the L1 to L2 messaging tree, which can then be used to prove\n/// its existence.\npub unconstrained fn get_l1_to_l2_membership_witness(\n    contract_address: AztecAddress,\n    message_hash: Field,\n    secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {\n    let returned_message =\n        get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret);\n    let leaf_index = returned_message[0];\n    let sibling_path = array::subarray(returned_message, 1);\n\n    (leaf_index, sibling_path)\n}\n\n// Obtains membership witness (index and sibling path) for a message in the L1 to L2 message tree.\n#[oracle(getL1ToL2MembershipWitness)]\nunconstrained fn get_l1_to_l2_membership_witness_oracle(\n    _contract_address: AztecAddress,\n    _message_hash: Field,\n    _secret: Field,\n) -> [Field; L1_TO_L2_MSG_TREE_HEIGHT + 1] {}\n"
     },
-    "90": {
+    "144": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
       "source": "use crate::utils::array;\nuse dep::protocol_types::{constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage};\n\nglobal LEAF_PREIMAGE_LENGTH: u32 = 4;\nglobal PUBLIC_DATA_WITNESS: u32 = 45;\n\npub struct PublicDataWitness {\n    pub index: Field,\n    pub leaf_preimage: PublicDataTreeLeafPreimage,\n    pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataTreeWitness)]\nunconstrained fn get_public_data_witness_oracle(\n    _block_number: u32,\n    _public_data_tree_index: Field,\n) -> [Field; PUBLIC_DATA_WITNESS] {}\n\npub unconstrained fn get_public_data_witness(\n    block_number: u32,\n    public_data_tree_index: Field,\n) -> PublicDataWitness {\n    let fields = get_public_data_witness_oracle(block_number, public_data_tree_index);\n    PublicDataWitness {\n        index: fields[0],\n        leaf_preimage: PublicDataTreeLeafPreimage {\n            slot: fields[1],\n            value: fields[2],\n            next_index: fields[3] as u32,\n            next_slot: fields[4],\n        },\n        path: array::subarray(fields, 1 + LEAF_PREIMAGE_LENGTH),\n    }\n}\n"
     },
-    "91": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+    "147": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/arguments.nr",
+      "source": "/// Notifies the simulator that `args` will later be used at some point during execution, referenced by their hash. This\n/// allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of arguments.\npub fn pack_arguments(args: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_oracle_wrapper(args) };\n}\n\n/// Same as `pack_arguments`, but using arrays instead of slices.\npub fn pack_arguments_array<let N: u32>(args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_arguments_array_oracle_wrapper(args) };\n}\n\nunconstrained fn pack_arguments_oracle_wrapper(args: [Field]) {\n    let _ = pack_arguments_oracle(args);\n}\n\nunconstrained fn pack_arguments_array_oracle_wrapper<let N: u32>(args: [Field; N]) {\n    let _ = pack_arguments_array_oracle(args);\n}\n\n#[oracle(packArguments)]\nunconstrained fn pack_arguments_oracle(_args: [Field]) -> Field {}\n\n#[oracle(packArgumentsArray)]\nunconstrained fn pack_arguments_array_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n"
     },
-    "99": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: BlockHeader,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert(\n            self.state.partial.public_data_tree.root\n                == root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path)\n                ,\n                \"Proving public value inclusion failed\",\n            );\n\n            // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n            // we have two scenarios:\n            // 1. The tree entry is initialized, and the value is the same as the one in the witness\n            // 2. The entry was never initialized, and the value is default zero (the default)\n            // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n            let preimage = witness.leaf_preimage;\n\n            let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n            let is_next_greater_than =\n                full_field_less_than(public_data_tree_index, preimage.next_slot);\n            let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n            let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n            let value = if is_in_range {\n                0\n            } else {\n                assert_eq(\n                    preimage.slot,\n                    public_data_tree_index,\n                    \"Public data tree index doesn't match witness\",\n                );\n                preimage.value\n            };\n\n            value\n        }\n}\n"
+    "150": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "111": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
-      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\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\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
+    "156": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "133": {
+    "159": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/messaging.nr",
       "source": "use crate::{\n    hash::{compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash},\n    oracle::get_l1_to_l2_membership_witness::get_l1_to_l2_membership_witness,\n};\n\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    merkle_tree::root::root_from_sibling_path,\n};\n\npub fn process_l1_to_l2_message(\n    l1_to_l2_root: Field,\n    contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    version: Field,\n    content: Field,\n    secret: Field,\n    leaf_index: Field,\n) -> Field {\n    let secret_hash = compute_secret_hash(secret);\n    let message_hash = compute_l1_to_l2_message_hash(\n        portal_contract_address,\n        chain_id,\n        contract_address,\n        version,\n        content,\n        secret_hash,\n        leaf_index,\n    );\n\n    // We prove that `message_hash` is in the tree by showing the derivation of the tree root, using a merkle path we\n    // get from an oracle.\n    let (_leaf_index, sibling_path) =\n        unsafe { get_l1_to_l2_membership_witness(contract_address, message_hash, secret) };\n\n    let root = root_from_sibling_path(message_hash, leaf_index, sibling_path);\n    assert(root == l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
-    "141": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
-      "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n};\nuse dep::protocol_types::{\n    constants::INITIALIZATION_SLOT_SEPARATOR,\n    traits::{Deserialize, Serialize},\n};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    pub fn read(self) -> T {\n        let header = self.context.get_block_header();\n        let mut fields = [0; T_SERIALIZED_LEN];\n\n        for i in 0..fields.len() {\n            fields[i] = header.public_storage_historical_read(\n                self.storage_slot + i as Field,\n                (*self.context).this_address(),\n            );\n        }\n        T::deserialize(fields)\n    }\n}\n"
-    },
-    "143": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
-      "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{\n    storage::map::derive_storage_slot_in_map,\n    traits::{Deserialize, Serialize, ToField},\n};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<T, N> for Map<K, T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
-    },
-    "144": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
-      "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::{Deserialize, Serialize};\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PublicMutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Serialize<T_SERIALIZED_LEN> + Deserialize<T_SERIALIZED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_SERIALIZED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Deserialize<T_SERIALIZED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
-    },
-    "175": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
+    "165": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: BlockHeader,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert(\n            self.state.partial.public_data_tree.root\n                == root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path)\n                ,\n                \"Proving public value inclusion failed\",\n            );\n\n            // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n            // we have two scenarios:\n            // 1. The tree entry is initialized, and the value is the same as the one in the witness\n            // 2. The entry was never initialized, and the value is default zero (the default)\n            // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n            let preimage = witness.leaf_preimage;\n\n            let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n            let is_next_greater_than =\n                full_field_less_than(public_data_tree_index, preimage.next_slot);\n            let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n            let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n            let value = if is_in_range {\n                0\n            } else {\n                assert_eq(\n                    preimage.slot,\n                    public_data_tree_index,\n                    \"Public data tree index doesn't match witness\",\n                );\n                preimage.value\n            };\n\n            value\n        }\n}\n"
     },
     "176": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
-    },
-    "179": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
-      "source": "use crate::{constants::ETH_ADDRESS_LENGTH, traits::{Deserialize, Empty, Serialize, ToField}};\n\npub struct EthAddress {\n    inner: Field,\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_LENGTH] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        EthAddress::from_field(fields[0])\n    }\n}\n\nimpl EthAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn from_field(field: Field) -> Self {\n        field.assert_max_bit_size::<160>();\n        Self { inner: field }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
+      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "241": {
+    "196": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "260": {
+    "197": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
-      "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n"
+      "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n"
     },
-    "263": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
-      "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    let mut node = leaf;\n    let indices: [u1; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\npub fn calculate_subtree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n    if depth == 0 {\n        0\n    } else if depth == 1 {\n        0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n    } else if depth == 2 {\n        0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n    } else if depth == 3 {\n        0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n    } else if depth == 4 {\n        0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n    } else if depth == 5 {\n        0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n    } else if depth == 6 {\n        0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n    } else if depth == 7 {\n        0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n    } else if depth == 8 {\n        0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n    } else if depth == 9 {\n        0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n    } else if depth == 10 {\n        0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n    } else {\n        panic(f\"depth should be between 0 and 10\")\n    }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n    // This is a test to ensure that we match the cpp implementation.\n    // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n    // to find the test that matches this.\n    let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n    assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n    let empty_root = calculate_subtree_root([0; 16]);\n    assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n    assert(calculate_empty_tree_root(0) == 0);\n\n    let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n    assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n    let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n    assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n    let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n    assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n    let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n    assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n    let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n    assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n    let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n    assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n    let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n    assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n    let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n    assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n    let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n    assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n    let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n    assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n"
-    },
-    "286": {
+    "259": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
       "source": "use crate::{\n    data::public_data_tree_leaf::PublicDataTreeLeaf,\n    merkle_tree::leaf_preimage::IndexedTreeLeafPreimage,\n    traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.slot == other.slot)\n            & (self.value == other.value)\n            & (self.next_slot == other.next_slot)\n            & (self.next_index == other.next_index)\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_slot == 0) & (self.next_index == 0)\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n\n    fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n        Self { slot: self.slot, value: self.value, next_slot, next_index }\n    }\n\n    fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n        Self {\n            slot: self.slot,\n            value: write.value,\n            next_slot: self.next_slot,\n            next_index: self.next_index,\n        }\n    }\n\n    fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n        Self {\n            slot: write.slot,\n            value: write.value,\n            next_slot: low_leaf.next_slot,\n            next_index: low_leaf.next_index,\n        }\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
     },
-    "291": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
-      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self.to_integer()]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
+    "267": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
+      "source": "use crate::{constants::ETH_ADDRESS_LENGTH, traits::{Deserialize, Empty, Serialize, ToField}};\n\npub struct EthAddress {\n    inner: Field,\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_LENGTH] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        EthAddress::from_field(fields[0])\n    }\n}\n\nimpl EthAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn from_field(field: Field) -> Self {\n        field.assert_max_bit_size::<160>();\n        Self { inner: field }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "292": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
-      "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
+    "269": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+    },
+    "284": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\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) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    // 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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn 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 two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "300": {
+    "285": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for U128 {\n    fn empty() -> Self {\n        U128::from_integer(0)\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for U128 {\n    fn to_field(self) -> Field {\n        self.to_integer()\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    fn from_field(value: Field) -> Self {\n        value as bool\n    }\n}\nimpl FromField for u1 {\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for U128 {\n    fn from_field(value: Field) -> Self {\n        U128::from_integer(value)\n    }\n}\n\n// docs:start:serialize\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// docs:start:deserialize\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    fn deserialize(fields: [Field; N]) -> Self {\n        str<N>::from(fields.map(|value| value as u8))\n    }\n}\n"
     },
-    "309": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
-      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
+    "294": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
+      "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "311": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+    "304": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
+      "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    let mut node = leaf;\n    let indices: [u1; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\npub fn calculate_subtree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n    if depth == 0 {\n        0\n    } else if depth == 1 {\n        0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n    } else if depth == 2 {\n        0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n    } else if depth == 3 {\n        0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n    } else if depth == 4 {\n        0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n    } else if depth == 5 {\n        0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n    } else if depth == 6 {\n        0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n    } else if depth == 7 {\n        0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n    } else if depth == 8 {\n        0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n    } else if depth == 9 {\n        0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n    } else if depth == 10 {\n        0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n    } else {\n        panic(f\"depth should be between 0 and 10\")\n    }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n    // This is a test to ensure that we match the cpp implementation.\n    // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n    // to find the test that matches this.\n    let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n    assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n    let empty_root = calculate_subtree_root([0; 16]);\n    assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n    assert(calculate_empty_tree_root(0) == 0);\n\n    let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n    assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n    let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n    assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n    let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n    assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n    let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n    assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n    let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n    assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n    let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n    assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n    let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n    assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n    let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n    assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n    let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n    assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n    let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n    assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n"
+    },
+    "309": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
+      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self.to_integer()]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "403": {
+    "408": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
       "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<U128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: Field) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: Field, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: Field) {\n        let new_balance = storage.balances.at(to).read().add(U128::from_integer(amount));\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: Field) {\n        let fee_limit = U128::from_integer(fee_limit);\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub Field {\n        storage.balances.at(owner).read().to_field()\n    }\n}\n"
     },
-    "404": {
+    "409": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
       "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: Field) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = amount.to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { std::hash::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     }