@aztec/protocol-contracts 0.66.0 → 0.67.1-devnet

package/artifacts/FeeJuice.json

@@ -1,45 +1,27 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
+  "noir_version": "1.0.0-beta.0+4184522b3ac6c4ce82aadf4911289cdf9fb0dd79-x8664",
   "name": "FeeJuice",
   "functions": [
     {
-      "name": "balance_of_public",
+      "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
           },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "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": "owner",
+            "name": "contract_address",
             "type": {
               "fields": [
                 {
@@ -53,42 +35,77 @@
               "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": "field"
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
           },
           "visibility": "public"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "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": [
-        "balance_of_public"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "public_dispatch",
+      "name": "check_balance",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "public",
+        "view"
       ],
       "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"
@@ -101,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"
@@ -113,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"
@@ -124,7 +133,7 @@
         },
         "parameters": [
           {
-            "name": "selector",
+            "name": "fee_limit",
             "type": {
               "kind": "field"
             },
@@ -133,30 +142,10 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "7V3bbhw5Dv0XP+dB1IUU51cWi0GSyQwMBMkgySywGMy/b7nbpe641C2wqo5dW6qXwI5FHuqIpStF/f3w26cPf/3x6+OX379+f/jlX38/fP768f2Px69fht/+/ufdw4dvj58/P/7x6/V/P7inf1hP5b//+f7L06/ff7z/9uPhl+jfPXz68tvDL8kN0r8/fv40/J9z//z73YNko0AOVgErgloR1IpAzpslxCpBZgwyY3gyS7BVIjizRLJKRDNGjGYJ66dB2cTuu0lJck7Dc2FyFGIpr/EMkMAA6tAA4Bp459AA6BqQtTvz5n7Ae2+W4GXVzk6ei+YgpWxw+aQ9OKj2BNVu7Sd8NLdwtI5YPplbOFl7es9klkhmCTO7Es0SeaF/kBb/iBP/sE2AzNoFqV0Jqj0BtYelI0FDO9Z2RWqnAOwPA2Wkdg+13QtSeyCoduQoF6KDasfarkjtaaFHkshYlkS1UdpTHo3xnnwpTRIqpcUTP5cWf2X7MNWsFHalnuIi3y9MLstlGquOX0xjQ8oHLRVaOG6ZFkeFluQbtFAay8Z8Uaxc+4B01KvEjbKRR4ujhquyZ/b0YG82e9Hxwd589ogO9hawd3y5C9jzK44amejlCjh6xeoPgtUfPVj/0p4z+4v+lFqlU/Fe4g1PZmJKBy0VWphelRZOrtDC6SdaTtbwlqyRuClr9FWtyT5fSseWAzOXUYlzaDhw5NElJVFsObDmYvZwthleOnDmg5YKLepfl5bLOZGSbpgW6+FEMh+nJ/Nxelo8XXexzAqHn/3LXj4RgwG8QwMkMEBA1yBaT6BSskYOMC0dsRoHvrx4adQCWLpn3gbIYICArkFA1yCia5CsnwIn62Ess/njWbrdeXfrnRl51MQSoNqtIxpncwtn65E+q7mFNZolzDGHLpglrOyKOfxOlk4A7h7Siieo9gTVjjy+lhCg2pHBIBKhtkdkMIgk5PG1JGSAmbCDao9Q7chRTqCjnAjU9uyh2qH9OzS0SqChVaLI/j27ANWO7N8zQW0nZP+ePbJ/z9AA4gwNIB7IgmpH9pE5Bqh2qO3JQ7Uv3cAbVkvjilzcZH2Ql845mvoTWL9i9S+deTT1Z6z+pbOPpn6wfy6dgTT1Y+1XB/y+KvEZKY37bzHxJUSgemaSvRvNGIbVnw6fT5anV7U85PF8LQZtnIQPM5gxviVTopeWE7ZPU8L2aeoDWP/CPscPa/jnsn440pvoX7r30dQvWP2RwPoTWL9i9Sdw+yZw+zK4fZcGs7T0C9h+AfungP0zg/0zg/1T12xfSVP9DNU/nAI6NEBEA2QwAHk0ALqRPaEB0DUIaDcNaDcNi920RE35YdNxChADGkDAAInQAAwGYHQNOKEBFAwga474mRqlk0taNMsl1JBHa/LrWqNF89BpTqzJYVPWvC43FGKxJk6t0fDK1oRizdW2RbHmlbmRS0tlfmkNufBm1micWvO63HgqLeX91BoKm7Lmlbkp1xWSZzexxoctWRNoU9YsnStcDkf9cCQ3GQhp8dZVEyChARQMsHj3qgkgYABGNzKjG5nRjbz0BlcbAF2DjHbTjHZTRbupot1U12zkmBulKfhydTSkq+vVUistrOOBmQg17lKR8uWallzdCH/aVJhWkHkcxSJfbTs8j2LexU5pSfdp2bS3vNXNO/IEvsFFHn0JbUCIcARFIwR4HaI5R65P0SwiS0NaWvlfh0MZNAI8C6/P8DoovA6KrkNwZvcLzpyYO5iz5Q4iyCR/w9hBWPUMVT8je3ewN7Q5Z+7gYPaGjub86MGcNncQsWdIZzvJ5sy5tDhZ2t1ocQpL14Et9RmqfvHVkYZ6hqqHXh4Z1EOtj9DMvIP6iOwho1Ooemhy3kE9dPCL2MEvYge/GLDWQzP0Duqx8foUY0ADZDBA8mgABgMwoQESGgDtpotTjDUB0DXIwA9tWpoljnsPw95b635ALkEIWSm9XPXFjP6EFdwJJUdogKUnlVo2HL1qBWBp6qs2QEIDKBhg6aZjGwBdg8U3QZoAAgZYeqAeXNmmHzabWun0Vry/NZjOS013F9M9T7lJhAZIaAAFA3BAAwgYQNCNLOhGFnQj54gGQNdA0W6qYDdlR2iAhAZYs5GvDoQLAEU0QAYDeI8GYDDA0isnbQB0Iwe0m0Z0DSLaTRPaTdOabsqtSJOf8s77Sdg6M23Kmk1xI6/MTUlSLi6GqTW8JWvyprjJr+03fPGbyeULVtqUNWlT1uiGrBEXNmVN3pI1tCluSLZkjX/lL1xisSbnqTW8JWvCprgJr8yNlre7iNzEmkibsmZT3KTX9psSJu00TK3hLVnDblPWxE1Zk7dkjYRNWbMpbrLflDWv+4WTLzOKYU/42pqK6lDeoQvx6g4HnyzPHsjjGUDAAAFdg+jQAOh7MTk5OEKEI6DvxWSG10HMcdHZdqb0JKIOfS9GF7/N3EQggiPA6+DhdfDwOtivS2gw34tR+3UJjdDQYIU+HzKoh4YGq/3KhrK9odl8L0bF3tDmp6dIs7eLmO/FqNpJ1mQXQd6L8YsTKLbUZ6h68lj1DFUPfTTLL06b2FAfHFZ9BPaQg3qFqoe+Y+EddPDzDjr4eQcd/PziNIkt9QmrHhuu7x34IQvvwC9ZeAd+ymIAYDAA+DGLASChAcBuOqyf0QDoGtD/670YvziRYJMb8MsWfnG6vzbA0i1fX8JQgo8yBVh8vtcESGgABQMszeDXBhAwAKMbmdGNzOhGXnpBsg2ArkFGu2lGu6mi3VTRbqprNnLSCcDiXHhtgAwGWLqZ0gZgMMDS9G9tAHQje7SbBnQNAtpNI9pN45puKq3ST9uAz6WHXanLkSE9BaBNrbibkdP7RFu2Pd233boF771t+nQWsaOIHcV80Dvw7uwidhS1o2i0i1hPhnxwwS6SzSJkRyExiyw/+L0fSODD8oPfFkJwcISERojwOiRz12DPwOeDvZsL9m4u2Lu5IHaUbEfJdhS1o6gZJTqyi9hRyI5C5oEhemcXsaMEO0qYgWIefqI5AsUb83+dRMwJOwcR8/AT7d1FtHcXUexNaZ8VGbNXnUTMEXPemAfqJKJ2h1FzUybn7SLmpkz2HibZe5hk72GMiY/OImaHMSYnOouYHSZFe1NGu8PYJyTJPiFJbG9KtjsM25tS7A6z9Li6PFcml23HRGfdS3d+7+oG2r00pe4d3YsTtNzVnXC6yQF1I+1WnO6ldy/u6hac7gi0OwLtTgGoG+gnDPRvAX6XArQ7A+1emojsrm6cn0h9wyaVd4XS1YtFY8Sc1PMEtYSqo+fQyT8L8dV2dhGqf34toTlI9fVYQ6i+gdMSmoOU5yDVd6tTeaaLnVSEdIZQfce6JTQDKbs4R2gOUn3nuiVUHYs4jddHWfxUqH4ltCU0BynMQar3ES2hNEdIZwjVw2tJaGwoEn9pKdL0LJZnieV5aHkW2o17NUIlF8PVY3WkXAs81HE/XYkbZYdDwuey8erKNemzLbIVW4Krb1O8kS26HVvChtqovvl2d5YQqL5WbQkl8+AYqL66bAnNQfJhjlCeIRTmIIU5SPX13N3BcRDiGUL1/bWW0BwknoPEc5DqK6iWUDQPjuFGqGVDKM9BynOQ1D6JCd75OUI8Q6j+aZALY39KLl/CaoYWqh1p5xGC9LrzdWeI+oe0LoTAIRK+FglfC8bXot5drApR71zWhUh4CF0BonzdQ5/xE0TtkmAYU9Flly+lva9G7RXN0V+2X3xtkjQoKCF7nvR+4eFkbJzoXF3R9XzmpN4vd85JPjh5yUn9pLxzTg4/ecnJjQjQzjk5/GTCCfmDkwknfHDykpN6FHbnnKSDk5ecBHdwMuEkdslJ2UFOV3k6Cyd9jsV3OYl9ztnucyI9csKlLP9c9MQJd/nt3OdEupzHNjg5vp0JJ/nwkyknh59MONHDT6acdLkuvstJdF2udxqcdLkubnDS5ZnXfU6oy3Vxg5Njbj/hxHe5Lm5w0sGc7VTR0MHG87miHcyuThWNHUyZzhXtYHw7V7SDyc2poqmDkehc0V6GF+5gnX+uaC/Di/QyvEgHy+xzRXsZXnIvw0sPkZ2nivYQrnmuaCcThuQ6WY/eSH21w4pSLy0a9jOOxktFk59UdD+rFymPUz/l85hd+MQK78bPLawQS3l7hnOesrKbbm5NVmQ3W1ersrKbDnRNVvazajGxIrk89pzddAzazxJnTVb2E1azKit9jkH3WeH9hNasykqfI3OLlaO3rbBCx8hcY+XwlQor/hiZa6wcI3OFlf1c8luVlWNkrrFy9LYVVuLR29ZYOXrbCiupz33bFiu7iX4wsaKkY/00TFnhPkfmFiuHr9RYqe9mU3kUlTxJg5XhUPG58DDSl7I3ctWHUbHEa73nrHB848jhzczZFjs37mi+kTlCu+lnAo2kPD01+vIjEdpN19GoqO+lRf1uFiSNiobd7P61KtpLi+4nQUyrovuJJlQtFSXfmLC5Mrsjd/Wm+8jKfhaCq7KynzB4CysUy8yP0iQoQ/azEFyVlf3Ena/IiuwnSH1NVvocg6g8KUdPTxW9ZEX77G2jG5PUDT9OfUX3E1m9Hit5Rzmo12Slz36lwcqOLmFYWEllm41Skikr+7mDsyIrO8pFvSYrfY5BDVZ2lHt5RVZ2lIJlTVb6HJkbrKT9ZMhYk5U+dxIarHCfM/4WK4evVFjZUcbuNVk5xqAKKzvK2r0iK3rM4mqs9LlDmaQEeyXVKSudrg7vsqKd7lC2WOl0DLrPSqd7ceESRBrCZN9WO92La7HS5xjUYqXPMajByn7C9FZlpc8xqMFKPHrbGivHyFxhpdNowRYrx8hcY+UYmSusdLqb3WKl05E5xcIKT3adtNMYygYruc8dyhYrnY5B91nRTucrDVY6ndveYyW6HSXhXpOVIzZ7Elk6sHLEZldY2U9quFVZOWKzK6zsJwnabVZOFd3RW4ONivbSojt6gu9+RW/sVVAsSZSI81VFa+aIp9Ee8eEyv9AaK+JKpyEu8v3CA8tSDHHqfip+tl/XsL+8fyHXz0JUTfJEow94ivFKdTpbdCsfzRtalLdm0Y24rLe0SLZmkW6OoxtryreziG6k+n5Di+pJgmNM4+3YGOWSQ4lrBkUeO8io4WrcOAPUH7VeEaA+9K0JoGCA+jM+KwLUH/+MqTjS8KNeA5ylZI6U3MAKuUhd+WGRuoEVSrVSChMpzTOkfP1x25hLuGXM8fJZnecdXqgupKWN1MUXQrFun8Qy+0ju5QQn1cOvNI6zIuXJpCjVc1o1ZOIMmWyXCTdCmu8lO3lqwTlSt8IGGlI8RyrNwkqzsHgWFs/CkllYMqu98iysPKtet4LIG1JxllSeIcXOz5IScx/D9UvoSmPHrmEqUw9quy9TD/lqyIhdJs6oT0zmvoyTmyEzA6e+yG3I2Ptmlhk4MgOnvnxSHn1URacyYpdRO47Up+QNmWSXoRk4NAdHG+1TkZkxFxCvdpkwA6eeQb4hI3aZZP8WbiQfa8jY+wOpj8kNGfs8UvIMnDyjPnmG7+iM9lG7H2Rn5+1GUpeGzAwc63f6z/Dbf95/e3z/4fOn74PE0x//+vLxx+PXL8+//vjvn+NfPnx7/Pz58Y9f//z29eOn3/769unXz18/Pv3twT3/86+h73g37GG4wZin1shZ3mWV4bdT55ZSfpc4PP1Kp7/GdznzYMRgyP8A",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLBCoQgEAbgd5lzB7Vc114llrCyEETDbGGJ3n0t2qVduuhlYAa/8TD/Ap1s5qFWprcTlNUC2rbCK2tCt6wZNE5prYb6PAa0FYz399MozNZOXjgPZUEykKaDkqKge6VlmCG0PjLAJBbksaCIBTQSkMsfeEHRQXjB2BdhTHZEU9AtBbEUdE9A+eX1Oc35B1F6/0VraJ/CKdFoeaSrn017Cpt/jfIvd6OzrexmJ7cEnsIXaoVZRkhYG1a/AQ==",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "check_balance"
       ]
     },
     {
@@ -313,7 +302,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -551,7 +540,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -644,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",
@@ -1442,7 +1452,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -1680,7 +1690,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -1773,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",
@@ -1791,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",
@@ -1808,245 +1839,33 @@
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-bef675b7a684e2c714f9f8a6499fb8fe-mega-honk-true"
-    },
-    {
-      "name": "check_balance",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "error_types": {
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "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."
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          }
-        },
-        "parameters": [
-          {
-            "name": "fee_limit",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "check_balance"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-41a705e163dc88ea5a4e4c2908443ccd-client-ivc-true"
     },
     {
-      "name": "_increase_public_balance",
-      "is_unconstrained": true,
+      "name": "initialize",
+      "is_unconstrained": false,
       "custom_attributes": [
-        "public",
-        "internal"
+        "private"
       ],
       "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": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
           }
         },
         "parameters": [
           {
-            "name": "to",
+            "name": "inputs",
             "type": {
               "fields": [
                 {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "_increase_public_balance"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "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": "tdfNaoQwFAXgd8k6i9z8TIyvUsoQNQ6BECVqoYjv3jhM26GzLGcj3nD9ApJDuDsbQrfdrjGP08Lat52lqfdrnHKt9oOzrsSU4u36vMzE+XDq3r/MPp/lsvqyslZLzkIeWGtE/XqMKdQ1Ud9fOu13p7U/nYaOd86chskGJl9gsoXJDUx2KJmEwNGEoyWOVjha42iDoy842uLoBkfj0ki4NBIujYRLI+HSSLg0Ei6N9M80OvXorL/2xbZAuwHaDmdLAbQJaEugrYC2BtoGaANzKYG5lMBcSlQuj1p9+BJ9l8JjsBq33D/NWevnHP6MXHOZ+jBsJZzD1+/cdZ5lpbnW96u9FqQkJ2XrJnWjLw==",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
-    },
-    {
-      "name": "initialize",
-      "is_unconstrained": false,
-      "custom_attributes": [
-        "private"
-      ],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          }
-        },
-        "parameters": [
-          {
-            "name": "inputs",
-            "type": {
-              "fields": [
-                {
-                  "name": "call_context",
+                  "name": "call_context",
                   "type": {
                     "fields": [
                       {
@@ -2145,7 +1964,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2383,7 +2202,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -2476,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",
@@ -3260,7 +3100,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3498,7 +3338,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -3591,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",
@@ -3609,8 +3470,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7VhbjuIwELxLvvPh7vajm6usViNeM4qEAPFYaYXm7msj7DDgATXLzgoNPyhOqnClynEFds1kOtq+vXTz18W6GfzYNbPFeLjpFvM42jVA+3Pr5XCehuvNcLVpBuDFtM10PomHwZj3tnntZtNmYNPxGRqZ+IBG9j0aLFbQ5EAOaHKCV9BiOBzQAgYKGrGmBAJT1s2m/270NbBBn8EmuGPwz7YB+zSmbox7GlM3xv+9MSQBD+gI4IIW2s8Q/vkMXJ0BBPIM6PHKDIEwBxDIhn4G/8DZyj18cb0vjJd9cZwz9dCLAeCkBs091EheB8HSlZSAQ4kpHpM/XjaVxxvEZTPjMbuTVYbw4Prxq/ULUUZHbUCnguotHvfWTCK4tjEwYbaIbbCXHQpcsNhDowF7NfXqJCy3QCTX1LDJDwuz0GU14Kg86P7oQYe4LSQ99caypuixzn3DTQ3905eqL+HpS9UXvocvdytBuYea/1ciZB5cP3y1/oslGAejVTebdW8vH37gmvRhPylsUwo7duXpArN0C8neQnK3kLyaFEeQsPX3R9dn4eRjh8YRJmSoEiXkKYXPXgYC6Cmop5CeYvUUp6d4PSXoKayniJrC+vRZnz7r02d9+qxPn/Xpsz591qfP9fStFEo4o4iaIkZPAT0F9RTSU6ySEkd04e/SAGXTDQHP9k777KC+g+Lw13DVDUezaSrodHU7H+e+jsPN72W+kht9uVqMp5Ptapq6va/1ZA6Z1pooBdLytNw6KjW3P4XUIpcCSwzHrefMEN9GtX2+6Ry4Fk3J7bNJ3uO9/AE=",
+      "bytecode": "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",
+      "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",
@@ -3618,8 +3479,231 @@
         "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "pack_arguments_oracle_wrapper"
       ],
-      "verification_key": "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",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-0bd3dd2a03004ee692247c75fe17f898-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-cb1d6ce3cc8513ad58244ad545bb40d7-client-ivc-true"
+    },
+    {
+      "name": "balance_of_public",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "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": "owner",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "field"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "balance_of_public"
+      ]
+    },
+    {
+      "name": "_increase_public_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "internal"
+      ],
+      "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": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "to",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "_increase_public_balance"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgEAbgd5lzh3S1sleJJawsBNEwW1iid19d2qVduuhlYAa/8TD/BoPo1qmVejQL1M0GyvTcSaN9t+0ZdFYqJaf2PIY8FITe75eZ69AujlsHNcEZCD1ATXOvR6mEn+XVfs8A4VhwiwUkFtBIgC9/YASxgzBCii9CfkFANAUVKahMQVUCul1en9G8+iCKy1+0+/bBreSdEke6xlX3p7C55yz+cjdb04thtSIk8BQ+XxtUZhj7tX71Cw==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "public_dispatch",
+      "is_unconstrained": true,
+      "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"
+          },
+          "206160798890201757": {
+            "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"
+          },
+          "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": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
     },
     {
       "name": "set_portal",
@@ -3663,7 +3747,7 @@
         "return_type": null
       },
       "bytecode": "JgACBAEnAAABBIBEJgAABAMmAgIEASYCAwQAHxgAAwACgEMtCIBDAAEkAAAAQCcCAAEEgEQmAgIEADoNAAEAAiQAAADcJgICAAIuDAACAAMcDAMEACsCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiMCAAYAAACMJAAAAQUmAgQAAAo4AwQFIwIABQAAAKcmAgYEADsJAQYoAgADADuaygIuDAADAAUKOAUEBiMCAAYAAADIJAAAARcnAgAEAN6tLwwABAADLwwAAQACJScAgAQEeAANAAAAgASAAyMAgAMAAAEEKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVaAuQbtR6pnzsBAQIlKQEAAQUfCi0n3IKHojsBAQIlLQAYyhjK",
-      "debug_symbols": "7VfdqoJAEH6XvfZiZnZ3ZrdXORzCykIQDbMDh+jdj0pqmRxBKoK8EUe++fk+Z3aZk9pEq+NuGafb7KAWXyeVZOuwiLO0tE7nQK3yOEni3fL6s4Lqwb7GH/ZhWpmHIswLtUARClSUbqpX78sI2ziJ1MIAnIM7NKGTC5oIqUWj6AG0EPIFLaSlRXszBAZoQgsY/h+M4EQ3ZYOHG/h3oMR8DlcHr+cK2HK1NMIVbYM1rgvseQDrfBPXI49gDTcVG6+vsLUkdpakJwkSzZrcaSKzJn1N9Dw7d5qY0SPWId5oUnvZKV52Ui7rpnixnuQ1PDWOOi9rRzqkLLjRG/mNL1cU/iCyjh5Ali20ZNnekK1zyPNzePv0HATwgByOXIc2Y43B3J6T7PRIYxhufrVYNGON4V1bNgLpXmMQyAeRRf0Isr6dNI/+TcmeS+snzONwlUSX/XF7TNdX62Txu496m+U+z9bR5phH1Y7ZrZdYzYPWgXbVBGJpGAqMKXOUef4A",
+      "debug_symbols": "7ZfdaoNAEIXfZa+92Jn9mZm8SinBJCYIYoIxhRLy7lWJG2OlUtuUQrwJWfnWOXOc2WXOapOsTrtlmm/3R7V4Oatsv47LdJ9Xq/MlUqsizbJ0t+w+Vrr+8dLwx0Oc18tjGRelWpDWFKkk39R/ra/esE2zRC3EXqJPMGgmc6VBix7DibClSSTAVvMAjcCtEkTAQJMZgAnBt7LRUFfHa6TIPk2qrIdSfagcDUGOw69tIc0tayGg6GmAZbZXVrSMsNa3gq2YwII0jrjZkXtHAHG2pG8JzZb0LDFz4/QtsaOnKwPcWdLsclN2uUmxHE/Z5c2kXfTn1yrjTZFzI8VXmdEqAf+zaxXIP0+uPHw9fE+Pdzro8a6rpwlBDw8h7tEhUA+2KFnffmZyYMeKQjgIAo3mV4uCkW+0HSkK78Pp69n0igI1PU+uYP57rhIOEgGZnuulWr3FRRqvsuQ6MG5P+bozP5bvh6Q3Sh6K/TrZnIqkHipv8yTUzWBMZLjuPqgXElmoYlRxPgA=",
       "brillig_names": [
         "set_portal"
       ]
@@ -3801,34 +3885,19 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  },
-                  {
-                    "name": "amount",
+                    "name": "fee_limit",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
+                "path": "FeeJuice::check_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
+          "path": "FeeJuice::check_balance_abi"
         },
         {
           "fields": [
@@ -3885,19 +3954,34 @@
               "type": {
                 "fields": [
                   {
-                    "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"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -3906,7 +3990,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -3919,21 +4003,21 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
+                  },
+                  {
+                    "name": "amount",
+                    "type": {
+                      "kind": "field"
+                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "FeeJuice::_increase_public_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::_increase_public_balance_abi"
         }
       ]
     }
@@ -3959,7 +4043,7 @@
       "path": "std/hash/sha256.nr",
       "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
     },
-    "51": {
+    "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
@@ -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"
     },
-    "93": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+    "66": {
+      "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"
     },
-    "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"
+    "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"
+    },
+    "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"
     },
-    "96": {
+    "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"
     },
-    "107": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, header::Header, 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: Header,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for Header {\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"
-    },
-    "112": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+    "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"
     },
-    "118": {
-      "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"
+    "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"
     },
-    "120": {
+    "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"
     },
-    "121": {
+    "141": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT, utils::arr_copy_slice,\n};\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 = arr_copy_slice(returned_message, [0; L1_TO_L2_MSG_TREE_HEIGHT], 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"
+      "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"
     },
-    "122": {
+    "144": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
-      "source": "use dep::protocol_types::{\n    constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage, utils::arr_copy_slice,\n};\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: arr_copy_slice(\n            fields,\n            [0; PUBLIC_DATA_TREE_HEIGHT],\n            1 + LEAF_PREIMAGE_LENGTH,\n        ),\n    }\n}\n"
+      "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"
     },
-    "127": {
-      "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"
+    "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"
+    },
+    "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"
     },
-    "142": {
+    "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"
     },
-    "170": {
-      "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"
+    "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"
     },
-    "173": {
-      "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_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"
+    "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"
     },
-    "174": {
-      "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"
+    "176": {
+      "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"
     },
-    "175": {
-      "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"
+    "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"
+    },
+    "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\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"
     },
-    "179": {
+    "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"
     },
-    "188": {
+    "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"
+    },
+    "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"
+    },
+    "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"
     },
-    "190": {
+    "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"
     },
-    "191": {
-      "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"
-    },
-    "195": {
-      "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    utils,\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    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\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"
-    },
-    "196": {
-      "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}, utils};\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    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n"
-    },
-    "220": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
-    },
-    "281": {
+    "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"
     },
-    "307": {
-      "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"
-    },
-    "308": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
-      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
-    },
-    "310": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
-      "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\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"
     },
-    "400": {
+    "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"
     },
-    "401": {
+    "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"
     }