@aztec/protocol-contracts 0.82.2-alpha-testnet.4 → 0.82.3

package/artifacts/FeeJuice.json

@@ -63,23 +63,26 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "_increase_public_balance"
       ]
     },
     {
-      "name": "public_dispatch",
+      "name": "check_balance",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "public",
+        "view"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "selector",
+            "name": "fee_limit",
             "type": {
-              "kind": "field"
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 128
             },
             "visibility": "private"
           }
@@ -90,19 +93,6 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
           "3219842053230618354": {
             "error_kind": "string",
             "string": "Function check_balance can only be called statically"
@@ -111,18 +101,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"
-          },
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
           "15238796416211288225": {
             "error_kind": "string",
             "string": "Balance too low"
@@ -137,84 +115,10 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "3305101268118424981": {
-            "error_kind": "string",
-            "string": "Attempted to delete past the length of a CapsuleArray"
-          },
-          "3367683922240523006": {
-            "error_kind": "fmtstring",
-            "length": 58,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "6753155520859132764": {
-            "error_kind": "string",
-            "string": "Failed to deliver note"
-          },
-          "8830323656616886390": {
-            "error_kind": "string",
-            "string": "Got a public log emitted by a different contract"
-          },
-          "13649294680379557736": {
-            "error_kind": "string",
-            "string": "extend_from_bounded_vec out of bounds"
-          },
-          "14657895983200220173": {
-            "error_kind": "string",
-            "string": "Attempted to read past the length of a CapsuleArray"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "length": 40,
-            "item_types": []
-          },
-          "16954218183513903507": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYdAIBGgEYGLgiARgABJQAAAEwlAAAAYigCAAEEgEcnAgIEADsNAAEAAigAgEMEAAMoAIBEBAAAKACARQQAASYlAAAD0x4CAAMJJwIEAAEKOAMEBSQCAAUAAACDJQAAA/weAgADAS0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBi0MBgctDgQHACgHAgctDgMHJwIDAAAtCAEEJwIGBAQAEAEGAScDBAQBACgEAgYtDAYHLQ4DBwAoBwIHLQ4DBwAoBwIHLQ4DBy0NBAYAKAYCBi0OBgQrAgAGAAAAAAAAAAACAAAAAAAAAAAtCAEHJwIIBAUAEAEIAScDBwQBACgHAggtDAgJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4GCS0NBAYAKAYCBi0OBgQtCAEGAAABAgEtDgQGLQ0HBAAoBAIELQ4EBy0IAQQAAAECAS0OBwQtCAEHAAABAgEuCoBEAActCAEIAAABAgEnAgkBAC0OCQgnAgoEAi4IgEQAAiMAAAGqDDgCCgskAgALAAACbiMAAAG8LQ0IAgo4AgkFJAIABQAAAdYnAgoEADwJAQonAgIECi0IAAotDAYLLQwEDC0MBw0tDAgOABAAAgAlAAAEDi0EAAAtDQYCLQ0EBS0NBwotDgIGLQ4FBC0OCgcnAgIBAS0OAggBKAAFgEUABC0NBAIKOAIDBAo4BAkDJAIAAwAAAkElAAAFZi8MAAIAAxwMAwQGHAwEAgAcDAIDBgw4AwECCjgCCQEkAgABAAACbSUAAAV4JiQCAAsAAAJ7IwAAA8InAgwEAgw4AgwNJAIADQAAApIlAAAFigAoBQIMADgMAg0tDQ0LLQ0HDC0NCA0KOA0JDiQCAA4AAAK+JwIPBAA8CQEPCygADIBDAA0kAgANAAADTyMAAALTLQ0GDC0NBA0tDQcOLQ0IDycCEQQDDDgOERIkAgASAAAC+iUAAAWKLgQADIADKACABAQABCUAAAWcLgiABQAQACgQAhEAOBEOEi0OCxIBKAAOgEUACw44DgsMJAIADAAAAzolAAAGKi0OEAYtDg0ELQ4LBy0ODwgjAAADwicCDAQNLQgADS0MBg4tDAQPLQwHEC0MCBEAEAAMACUAAAQOLQQAAC0NBgwtDQQNLQ0IDi4EAAyAAygAgAQEAAQlAAAFnC4IgAUADwAoDwIQASgAEIBEABEtDgsRLQ4PBi0ODQQuCoBFAActDg4IIwAAA8IBKAACgEUACy0MCwIjAAABqigAgAQEeAANAAAAgASAAyQAgAMAAAP7KgEAAQX3ofOvpa3UyjwBAQImKgEAAQUsry1Jt6zm8jwBAQImJQAAA9MuCIBEAAUjAAAEHg0oAAWAQwAGJAIABgAABI4jAAAEMy0NAQUtDQIGLQ0DBy0NBAgnAgkEBC0IAQonAgsEBQAQAQsBJwMKBAEAKAYCCycCDAQEACgKAg0/DwALAA0tDQoGACgGAgYtDgYKLQ4FAS0OCgItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEUABiQCAAcAAASsIwAABV0tDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAATTJQAABYoAKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAAAE+CUAAAWKACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAAAFIiUAAAWKLgQACIADKACABAQABSUAAAWcLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAABV0tDAYFIwAABB4qAQABBQLcbieAdhKdPAEBAiYqAQABBdN7FJoYxQChPAEBAiYqAQABBeidCf6hES0OPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAAW3IwAABcIuAIADgAUjAAAGKS4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAAYVLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAAXkKAGABQQAAQMAgAYAAoAGIwAABikmKgEAAQVFp8pxGUHkFTwBAQIm",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "check_balance"
       ]
     },
     {
@@ -1816,7 +1720,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VnRTiMxDPyXfd6H2I4dm185nVCBgipVLSrlpBPi3y+pyAZotlV6PTjEvlSbrWdtzySZdPvU3cyvHu8uF6vb9UN38eOpW66vZ9vFehVHTx343b2H+9kqDR+2s822u0Cv1nfz1U28ZPbPfXe7WM67C0B+7vej0bscjYJDtEklmJzxSzCB6OFgYGP/Eh2vX4WjYq0SQMmVgOcSbVZ7Ognlh3twb6J/9h3wRM0YNTJRM0ZNqFODVKjhI9R4kEykR1eiA+0y6D/PYLUMgBBy46iFVK4lAFDOGeK1Fn2lqq8QZn0DwFF9SyVs5I7oC8KawyWEv9MX3cTNKDcwcTPKDU7cjHJD/zs3n+cn6CduRrnhc3BjOHBjZEe4CXnWeyrMALtdOXKGcswXqSxRfqicGEHDMjTjN0ZeIz9YYV/xve9j+OoN6Ec3gM7JcIx1CHS4gdjh8GwslYDXXfn1cxfBMEOJ5HD5cRfPGYzQHa5GXV66+mrio0IqhuoHHfKDXiR8pBjhvHwtvMpQ19YXIhntPTdUP1t4HMrxCt90HyScuBnlhs7Bzdk8gvwZyvnMLZb4qzcgH93AGT0ijq42i+VycXf55jWeSx++Kg0TvDyOg7yfjl7aIaEdou0Qa4TEEexeaFaBPuQFLOj3KMUUGaqbqGmeS2Z7FhmoHeLbIdwOkXZIaIdoO8SaIeraIdAOaVdf29XXdvW1XX1tV1/b1dd29bVdfaurL8N5wjncw8AJGDwBQydg/AkYPgEjrZg4ot0GWv/bQwYPRjHb20L9ZEBx+Gu2WcyulvPkyenbx9V1tug43P6+z99kE7/frK/nN4+bebLz4uRpYsUDtsdYCKQVwNCzFI9LtxB6lMG9EiIe4MUywrQHR0XVdC/+DEYc1BpL8hx7+QM=",
+      "debug_symbols": "7VnbbuIwEP2XPOfBc/F4pr+yWlW0pRUSgorSlVZV/32dqHYoOCCzbLtV84LiMCczc47tY8JLcze/eX64Xqzu10/N1Y+XZrm+nW0X61UcvTTA/b2nx9mqGz5tZ5ttc4Ws1jbz1V289J5f2+Z+sZw3V4DhtT2MRnYpGgVztGkhmJz5t2AC0ePB4M3zW3S83glH5VIlgJIqAfY5mhyUnk5C6eEM7l30z7YBP1EzRo1M1IxRE8rUIA3U+BPUMEgiktEN0YH6DPrPM1gpAyCE1DjqQGqX7DAY1KcM8VoHfUVK+gph0jcAnNR3qMQbuRP6gnhN4RLC3+mLbuJmlBuYuBnlBiduRrmh/52bz/MT5ImbUW78JbgxzNwY2QluQpr1TAMz4LEvRy5QjvEglZkcLydGUF6GZv6dkZfIDzawr7jv+xi+egP60Q2gc5KPsQ6BjjcQO8zPRt2ZQK4vv3zuIsgzlEiOlx938ZTBCN3xatSlpas7Ex+155LKBx3irBeJP1GM+LR8LexkKGvLA5EebZ8bKp8tGHM5rPBN90HCiZtRbugS3FzMI4gvUM5nbrHkv3oD8tENXNAj4uhms1guFw/X717jue6Di9J4grfH+SD705GlHhLqIVoPsUpIHEH/QrMI5JAWsCAfUIpdZChuoqZpLpkdWGSgegjXQ3w9ROohoR6i9RCrhqirh0A9pF59rVdf69XXevW1Xn2tV1/r1dd69a2svuTzhHN4gIEzMHgGhs7A8BkYfwZGajFxRP0GWv7bQ7IHo5gdbKE8GVAc/pptFrOb5bzz5O7b59Vtsug43P5+TN8kE3/crG/nd8+beWfng5N3EysesBljIdCtAA+tl8HjulsILUp2rw4RD/BiCWHagqNB1e5e/BmMmNUaS/Iae/kD",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper",
@@ -1827,19 +1731,92 @@
       "verification_key": "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"
     },
     {
-      "name": "balance_of_public",
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "3305101268118424981": {
+            "error_kind": "string",
+            "string": "Attempted to delete past the length of a CapsuleArray"
+          },
+          "3367683922240523006": {
+            "error_kind": "fmtstring",
+            "length": 58,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
+          "6753155520859132764": {
+            "error_kind": "string",
+            "string": "Failed to deliver note"
+          },
+          "8830323656616886390": {
+            "error_kind": "string",
+            "string": "Got a public log emitted by a different contract"
+          },
+          "13649294680379557736": {
+            "error_kind": "string",
+            "string": "extend_from_bounded_vec out of bounds"
+          },
+          "14657895983200220173": {
+            "error_kind": "string",
+            "string": "Attempted to read past the length of a CapsuleArray"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "length": 40,
+            "item_types": []
+          },
+          "16954218183513903507": {
+            "error_kind": "string",
+            "string": "Attempted to read past end of BoundedVec"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "set_portal",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "view"
+        "public"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "owner",
+            "name": "portal_address",
             "type": {
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress",
               "fields": [
                 {
                   "name": "inner",
@@ -1852,26 +1829,19 @@
             "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "integer",
-            "sign": "unsigned",
-            "width": 128
-          },
-          "visibility": "public"
-        },
+        "return_type": null,
         "error_types": {
-          "206160798890201757": {
+          "2236649814169388962": {
             "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+            "string": "PublicImmutable already initialized"
           },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6067862452620309358": {
+          "6485997221020871071": {
             "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
+            "string": "call to assert_max_bit_size"
           },
           "16761564377371454734": {
             "error_kind": "string",
@@ -1883,211 +1853,66 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z1bbus4DIb3kuc+iNT9bOVgUPR2igBBUqTtAIOiex8nje00EuKxKBTJ6H8p6oQMqc+ySUuU/LF4fLp/f75drv9sXhe/fn8sVpuHu7flZt0dfXzeLO63y9Vq+Xx7/PFC7f6Q4r3C68vdenf8+na3fVv8IkNW3Sye1o/7/z13P/JnuXrqjth+3iTynlQ8iPu9xEHam4xwZMcH4cjhm/BfN51H/r94ZL55tNMjLtQrtMe2TE+rnJ4mbw9qmuKoZXO4STnd2yDSownnctLB9cIxDLKdlS93zGW5Ey/KHXNZdMxl0bGXRceGi3LH8WW54y/KHU8/7Y7t3WHF39zJxLNoejd8jOMvc+CMtB5+2bAaZXOxj7tG9V4w8Xlhy/3vWvbHont+Dvwk/IICPxE/C34SfhH9T8YP/U/CjxX6n4yfAT8RvwB+En6kwU/Ez4OfhB8z+In44fltkp/rR1Kto1N+GvmLjB/yZxm/CH5T/AZZ9110x8/h+pXxM+An4ofrV8TPo//J+KH/ifgF9D8ZP4y/iPhFPP/K+GH8RcJPK8yfy/hh/EXEj/D8JuOH8RcZP+TPKRTGpFAGCjLdFIpG+pqBgpwghWKQaGagIHpnoCAkp1B+vkb+GqAgJKdQHEJyBgqGiVIoWDuRg4KQnELBKoccFKT5KRSsR8hBwT0lgWKwciADhduEwnqEYuwpFN1mmu+p3wyBvdbFwjuCps1ngjkEu3YM7XOBEoJtPkBUJGjbDIIVCTZa61qToAHBKYLeD/st+JjE4kbrXSsS9G1OrtYkiFgsJBjaHPmrSRDZjJQgIomQYDQgKCSIPigjaBWyGSlBZDNCgoRsRkoQ2YyUICKJkGCjRcc1CSKSCAk2Ws5ck2CbRRGzCEbqNy6nyAnBn98r+n9HsMJ8MYXQWziekc4TtNb30t2kw8iQOOQYOt8jDKMb9LVvvbX6mp2/ZvLOXbHz07WcrNyU8zoOdw333UTGHRv6mg3v1MS7GrwO/Q3JG+bzwp0fY4gho+Kx+L6t/sfb6se2Ht3J8u476k8UOT3+tNZ+733gq/b+mtm7RldrazV4ocmchEvX6PDJBBT0lBQKG0BJobQ58nMeikZPyUBBT0mhmDaH/TjyAEXZicddNTwbd00NCcE2h/0qErRtZkCzCJIe22cpIdhmulSRYKOlqTUJthleKxJstDR1HkFnh/aFJJI0WpI1i6BR45tNVdIHY5uLveoR9KrNScyaBJHNCAk2uq3jLIKWh/ZZqxKCbZZkVSTY6lrqigQRi4UENTJqKUE81QkJGmQzQoIYHxQTxBi1kGCj2/rVJIg+KCTY6IaB8wj6oTTVRk4IIpsREmz0hU0VCTb6yqGaBBFJZARDo68dqkkQ44NSgojFQoKE8cFJgnpcqqT16TxJaHTRa02CiMVCghqxWEoQsVhKELFYSBB11GKCyGaEBC36oJQgshkhQYdsRkoQ2YyUILKZaYJmWKmt3elMU2j0LUwVCQaM8ksJIhYLCUbkg1KCeCaREYyo5ZcSRC2/cDVEJAOCQoK4DwoJNrp3S0WCqOU/IdhBIcXZJzU/bPHljU508hXp0fSGok3tWFWgYwp0wnydfG3u+U0nuo98iVa+BnNSy5VohSJbochWLLIVS2yRoiKtkvNFVGSLitqVX/E2qWWKtEKJluYiLT/7HkMmyz2qfjPByBmd+fclyl/F5+34At/yI2ITOnG+TtDzGYT590yK8+1w/rqd0Jl/TpkK7FCBnfz1Gm3fr6PnVMfO19EFdvIv3T2vk5+DntApsGML7ORn1o7OT0YnH9fPn1Pn5+v4AjtBFejY+Tqx4FqI8+8HWukCnThfh0yBToEdLmgPz+87WlOBzsx+8Nkd/X23Xd7dr55eO43dl+/rh7flZn04fPvnpf/mfrtcrZbPty/bzcPT4/v26Xa1edh9t1CHP7+7Dn/DUe8zuO5wt2k2fR3uGsPRdN+6zmpn+V8=",
+      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYuCIBGAAElAAAARSUAAABbKAIAAQSARycCAgQAOw0AAQACKACAQwQAAygAgEQEAAAoAIBFBAABJiUAAANZJwICAAIvDAACAAMcDAMEACwCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiQCAAYAAACnJQAAA4InAgQAAAo4AwQFJAIABQAAAMInAgYEADwJAQYpAgADADuaygIvDAADAAUKOAUEBiQCAAYAAADjJQAAA5QoAgAFAN6tMAwABQADLQgBAycCBQQEABABBQEnAwMEAQAoAwIFLQwFBi0OBAYAKAYCBi0OBAYAKAYCBi0OBAYtDQMFACgFAgUtDgUDKwIABQAAAAAAAAAAAQAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OBAgAKAgCCC0OBAgAKAgCCC0OBAgAKAgCCC0OBQgtDQMEACgEAgQtDgQDLQgBBAAAAQIBLQ4DBC0NBgMAKAMCAy0OAwYtCAEDAAABAgEtDgYDLQgBBQAAAQIBLgqARAAFLQgBBgAAAQIBJwIHAQAtDgcGLQ0FCC0NBgkKOAkHCiQCAAoAAAHyJwILBAA8CQELCygACIBDAAkkAgAJAAACgyMAAAIHLQ0ECC0NAwktDQUKLQ0GCycCDQQDDDgKDQ4kAgAOAAACLiUAAAOmLgQACIADKACABAQABCUAAAO4LgiABQAMACgMAg0AOA0KDi0OAQ4BKAAKgEUACA44CggNJAIADQAAAm4lAAAERi0ODAQtDgkDLQ4IBS0OCwYjAAAC9icCCAQJLQgACS0MBAotDAMLLQwFDC0MBg0AEAAIACUAAARYLQQAAC0NBAgtDQMJLQ0GCi4EAAiAAygAgAQEAAQlAAADuC4IgAUACwAoCwIMASgADIBEAA0tDgENLQ4LBC0OCQMuCoBFAAUtDgoGIwAAAvYtDQYICjgIBwkkAgAJAAADECcCCgQAPAkBCicCBwQILQgACC0MBAktDAMKLQwFCy0MBgwAEAAHACUAAARYLQQAAC0NAwQBKAAEgEUABS0NBQMwDAABAAInAgEAAzAMAAMAASYoAIAEBHgADQAAAIAEgAMkAIADAAADgSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFWgLkG7UeqZ88AQECJioBAAEFHwotJ9yCh6I8AQECJioBAAEF6J0J/qERLQ48AQECJi4BgAOABgsAgAYAAoAHJACABwAAA9MjAAAD3i4AgAOABSMAAARFLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABDEuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABAAoAYAFBAABAwCABgACgAYjAAAERSYqAQABBUWnynEZQeQVPAEBAiYlAAADWS4IgEQABSMAAARoDSgABYBDAAYkAgAGAAAE2CMAAAR9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARQAGJAIABwAABPYjAAAFpy0NAQctDQIILQ0DCS0NBAonAgwEBAw4BQwNJAIADQAABR0lAAADpgAoCAIMADgMBQ0tDQ0LJwINBAMMOAUNDiQCAA4AAAVCJQAAA6YAKAcCDQA4DQUOLQ0ODAA4CwwNJwIMBAQMOAUMDiQCAA4AAAVsJQAAA6YuBAAIgAMoAIAEBAAFJQAAA7guCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAFpy0MBgUjAAAEaA==",
+      "debug_symbols": "7Z3bbuM4DIbfJde9kKjzvMpgUfSQKQIESZG2CyyKefd1gsr2OGwci5ruDvTfFHFDmtJnSqR1yvvqcX3/9nS72f3Yv6y+fX9fbfcPd6+b/a67ev95s7o/bLbbzdPt+N8rdfyT/En+5flud7x8eb07vK6+6ZDizWq9e+w+RnLdHX5stuvVN9d9PBM2ztKHsPFqENaBk9YUXb61GUmT4qSDi/ZDOozvHSwnbKLJwpbosrDWJvhcEG1VGov/dbPSSoPMJ2TC/5xMGMiQulzZFPo7KzXIkg/cnSkNN56R7ciZHqKPM9IuZGGXBt46nnhrAu+v5G0TeH8lb2fB+yt5e/QnX8t7Pl6aMOZ9VApUolRiKboCpaRKlPiGHu2gFPVlx6NE4UOYkqMZx/vvkiRSpqG6pgp1TSp3KGrSoRxNaPvbTRD9fhNBbMJ0nVE20TWoGaeIyuQnF5WLM04RTd8/xqTmnMIOnbp25KdOYWw7dbVKXlcKuUCGxjGEj6jKqj7ujWMZH1GTzcUPKZlBOlo2tmeMdhR9iROl7qnkHoo0XRbuuOUYSWEseiJoQVBIMIGgjKCDD0oJwgeFBD18UEowgqCMYCAQFBIMICgjGDUICgl6EJQRTHiru4Kgz0V2Xp8RtCAoJIiMWkbQVBiIbYBgL+t/FT0SJLRiKUG8kwgJGrRiKUH4oJCghQ9KCcIHhQQdxmakBPFeLCToMTYjJehAUEYwYGxGStCCoJAgxmaEBCMy6inBExZMH3FYEnJfFgsSWgaLVcgQWCxIPVksiOUcFo0AzWLBOBaHhRCgWSwI0BwWg2EkFgsCNIsFAZrDgn0TLBaH5J/FAm9hsaBv4bBgLwKPpdXkn1Le80+/7OJnt0wqnYYyxynDZrcY1GTY6mvFIobaDMc4uOniUNvsNoOaDFuNnhUZNrtQviZDxOVrGPrhJIM4jSlOoy1fwbCbW8pltmrqh45aHTOvybDVGfCKDJsdX63JsNXB2EUMuy4vl9k5NWXY7OE4NRnCD8UMHeKynCFybDHDZodVKzIMyG3kDDF+KGYYMY4tZ4h3PTHDZpdG12SI/vAahoF6hmk6N+qVBUMxQ4zBihlqxBQxw2ZX89ZkiJgiZmgwfihniLgsZtjs8S+LGBrdMzRGnzHE+KGYYbNHwNRkiLgsZugRl+UMEZflDBFTxAwDchs5Q/ihmCHmUyowRG4jZtjs0e81GVowvIKhDT1DP52TCs0eYlOTIeYCxAw14rKcIfJDMUPsrZAzxL6ACgyxHlu6tyI0e6JLRYaYk6rAEH4oZtjsvoDQH9FAwZhi4SND32qOvYSh9r5fw+njmR/6Vt/1KjIMreY2FRnGVsdtajK0YDjPMIR8Yx2SO2PYam5TkWFqNceuyRBxWcowqlbHbWoyRG4jZ4iYImaoLRiKGcIPxQybnU+pyRC5zRUM07BWJNEZw2bnU2oyrNEf9icsGnJzDKMyuaJdYjWcJRi4woeufBlhTOqysNY2DscUOvJj8WNdq5yH9IfUtcpZ9n9GXbUmdiIhDDbsdNy8uyfr+MnmxpKcO9PhD4Oa0QnLdfjfyp3R4Z374mnQWn/yi6hzWrZIK5VoxSJbschWKrKVSmyRKrFFWhVpldkqqtcnyeGcVijR+mRRypxWSUsh/kDCi30M8b+zklT+oYBEjM7yfon4VnzZTigoG79Z4bIOvzh/RscvZ5B0gc5yO4ZvtzM6y5+p0QV2dIEdvr0ml/06BTrXict1TIEdqwt0/HIdV2DHFdjhNz+Ong+n45Y/06AKdArsRFOgE5frpOVtwSpdoLO8P7D8IucZneU54Sc/kzijU1Afowp0Cp6PWegHP7urv+8Om7v77fql0zh++bZ7eN3sdx+Xr/8852/uD5vtdvN0+3zYP6wf3w7r2+3+4fjdSn38+a674RmdwrEsp0uvb7qp5VNCd7oM3WXqrHaW/wU=",
       "brillig_names": [
-        "balance_of_public"
+        "set_portal"
       ]
     },
     {
-      "name": "process_log",
+      "name": "public_dispatch",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "custom_attributes": [
+        "public"
+      ],
       "abi": {
         "parameters": [
           {
-            "name": "_log_ciphertext",
-            "type": {
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec",
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 18,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_tx_hash",
+            "name": "selector",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
-          },
-          {
-            "name": "_unique_note_hashes_in_tx",
-            "type": {
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec",
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 64,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_first_nullifier_in_tx",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_recipient",
-            "type": {
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
           }
         ],
         "return_type": null,
         "error_types": {
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "length": 40,
-            "item_types": []
-          },
-          "17843811134343075018": {
+          "206160798890201757": {
             "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
-      "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiRo43/zJPdhos9kSduNJwChARUacAYDdIEGCDRAogEnNKBEAxQagDZZo03WaJM12mRCm0xokwltMqFNJrTJhDaZ0CYT2mSCmryl9DDRmdrbveF0S2gOhWd+jvan+4xxaGy7RJtb0LcA5ddYSq5kvna2V1QFF5VKkAR6AQ==",
-      "brillig_names": [
-        "process_log"
-      ]
-    },
-    {
-      "name": "set_portal",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "portal_address",
-            "type": {
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress",
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
           "2236649814169388962": {
             "error_kind": "string",
             "string": "PublicImmutable already initialized"
           },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
           },
-          "6485997221020871071": {
+          "3219842053230618354": {
             "error_kind": "string",
-            "string": "call to assert_max_bit_size"
+            "string": "Function check_balance can only be called statically"
           },
-          "16761564377371454734": {
+          "5019202896831570965": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "attempt to add with overflow"
           },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYuCIBGAAElAAAARSUAAABbKAIAAQSARycCAgQAOw0AAQACKACAQwQAAygAgEQEAAAoAIBFBAABJiUAAANZJwICAAIvDAACAAMcDAMEACwCAAUAAAAAAAAAAAAAAAAA//////////////////////////8OOAQFBiQCAAYAAACnJQAAA4InAgQAAAo4AwQFJAIABQAAAMInAgYEADwJAQYpAgADADuaygIvDAADAAUKOAUEBiQCAAYAAADjJQAAA5QoAgAFAN6tMAwABQADLQgBAycCBQQEABABBQEnAwMEAQAoAwIFLQwFBi0OBAYAKAYCBi0OBAYAKAYCBi0OBAYtDQMFACgFAgUtDgUDKwIABQAAAAAAAAAAAQAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OBAgAKAgCCC0OBAgAKAgCCC0OBAgAKAgCCC0OBQgtDQMEACgEAgQtDgQDLQgBBAAAAQIBLQ4DBC0NBgMAKAMCAy0OAwYtCAEDAAABAgEtDgYDLQgBBQAAAQIBLgqARAAFLQgBBgAAAQIBJwIHAQAtDgcGLQ0FCC0NBgkKOAkHCiQCAAoAAAHyJwILBAA8CQELCygACIBDAAkkAgAJAAACgyMAAAIHLQ0ECC0NAwktDQUKLQ0GCycCDQQDDDgKDQ4kAgAOAAACLiUAAAOmLgQACIADKACABAQABCUAAAO4LgiABQAMACgMAg0AOA0KDi0OAQ4BKAAKgEUACA44CggNJAIADQAAAm4lAAAERi0ODAQtDgkDLQ4IBS0OCwYjAAAC9icCCAQJLQgACS0MBAotDAMLLQwFDC0MBg0AEAAIACUAAARYLQQAAC0NBAgtDQMJLQ0GCi4EAAiAAygAgAQEAAQlAAADuC4IgAUACwAoCwIMASgADIBEAA0tDgENLQ4LBC0OCQMuCoBFAAUtDgoGIwAAAvYtDQYICjgIBwkkAgAJAAADECcCCgQAPAkBCicCBwQILQgACC0MBAktDAMKLQwFCy0MBgwAEAAHACUAAARYLQQAAC0NAwQBKAAEgEUABS0NBQMwDAABAAInAgEAAzAMAAMAASYoAIAEBHgADQAAAIAEgAMkAIADAAADgSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFWgLkG7UeqZ88AQECJioBAAEFHwotJ9yCh6I8AQECJioBAAEF6J0J/qERLQ48AQECJi4BgAOABgsAgAYAAoAHJACABwAAA9MjAAAD3i4AgAOABSMAAARFLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABDEuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABAAoAYAFBAABAwCABgACgAYjAAAERSYqAQABBUWnynEZQeQVPAEBAiYlAAADWS4IgEQABSMAAARoDSgABYBDAAYkAgAGAAAE2CMAAAR9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARQAGJAIABwAABPYjAAAFpy0NAQctDQIILQ0DCS0NBAonAgwEBAw4BQwNJAIADQAABR0lAAADpgAoCAIMADgMBQ0tDQ0LJwINBAMMOAUNDiQCAA4AAAVCJQAAA6YAKAcCDQA4DQUOLQ0ODAA4CwwNJwIMBAQMOAUMDiQCAA4AAAVsJQAAA6YuBAAIgAMoAIAEBAAFJQAAA7guCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAFpy0MBgUjAAAEaA==",
-      "debug_symbols": "7Z3bbuM4DIbfJde9kKjzvMpgUfSQKQIESZG2CyyKefd1gsr2OGwci5ruDvTfFHFDmtJnSqR1yvvqcX3/9nS72f3Yv6y+fX9fbfcPd6+b/a67ev95s7o/bLbbzdPt+N8rdfyT/En+5flud7x8eb07vK6+6ZDizWq9e+w+RnLdHX5stuvVN9d9PBM2ztKHsPFqENbBMNKaosu3NiNpUpx0cNF+SIfxvYPlhE00WdgSXRbW2gSfC6KtSmPxv25WWmmQ+YRM+J+TCQMZUpcrm0J/Z6UGWfJcqQOl4cYzsh0500P0cUbahSzs0sBbxxNvTeD9lbxtAu+v5O0seH8lb4/+5Gt5z8dLE8a8j0qBSpRKLEVXoJRUiRLf0KMdlKK+7HiUKHwIU3I043j/XZLUuXZDdU0V6ppU7lDUpEM5mtD2t5sg+v0mgtiE6TqjbKJrUDNOEZXJTy4qF2ecIpq+f4xJzTmFHTp17chPncLYdupqlbyuFHKBDI1jCB9RlVV93BvHMj6iJpuLH1Iyg3QkNrZnjHYUfYkDQ91TyT0Uabos3HHLMZLCWPRE0IKgkGACQRlBBx+UEoQPCgl6+KCUYARBGcFAICgkGEBQRjBqEBQS9CAoI5jwVncFQZ+L7Lw+I2hBUEgQGbWMoKkwENsAwV7W/yp6JEhoxVKCeCcREjRoxVKC8EEhQQsflBKEDwoJOozNSAnivVhI0GNsRkrQgaCMYMDYjJSgBUEhQYzNCAlGZNRTgicsmD7isCTkviwWJLQMFquQIbBYkHqyWBDLOSwaAZrFgnEsDgshQLNYEKA5LAbDSCwWBGgWCwI0hwX7JlgsDsk/iwXewmJB38JhwV4EHkuryT+lvOefftnFz26ZVDoNZY5Ths1uMajJsNXXikUMtRmOcXDTxaG22W0GNRm2Gj0rMmx2oXxNhojL1zD0w0kGcRpTnEZbvoJhN7eUy2zV1A8dtTpmXpNhqzPgFRk2O75ak2Grg7GLGHZdXi6zc2rKsNnDcWoyhB+KGTrEZTlD5Nhihs0Oq1ZkGJDbyBli/FDMMGIcW84Q73pihs0uja7JEP3hNQwD9QzTdG7UKwuGYoYYgxUz1IgpYobNruatyRAxRczQYPxQzhBxWcyw2eNfFjE0umdojD5jiPFDMcNmj4CpyRBxWczQIy7LGSIuyxkipogZBuQ2cobwQzFDzKdUYIjcRsyw2aPfazK0YHgFQxt6hn46JxWaPcSmJkPMBYgZasRlOUPkh2KG2FshZ4h9ARUYYj22dG9FaPZEl4oMMSdVgSH8UMyw2X0BoT+igYIxxcJHhr7VHHsJQ+19v4bTxzM/9K2+61VkGFrNbSoyjK2O29RkaMFwnmEI+cY6JHfGsNXcpiLD1GqOXZMh4rKUYVStjtvUZIjcRs4QMUXMUFswFDOEH4oZNjufUpMhcpsrGKZhrUiiM4bNzqfUZFijP+xPWDTk5hhGZXJFu8RqOEswcIUPXfkywpjUZWGtbRyOKXTkx+LHulY5D+kPqWuVs+z/jLpqTexEQhhs2Om4eXdP1vGTzY0lOXemwx8GNaMTluvwv5U7o8M798XToLX+5BdR57RskVYq0YpFtmKRrVRkK5XYIlVii7Qq0iqzVVSvT5LDOa1QovXJopQ5rZKWQvyBhBf7GOJ/ZyWp/EMBiRid5f0S8a34sp1QUDZ+s8JlHX5x/oyOX84g6QKd5XYM325ndJY/U6ML7OgCO3x7TS77dQp0rhOX65gCO1YX6PjlOq7Ajiuww29+HD0fTsctf6ZBFegU2ImmQCcu10nL24JVukBneX9g+UXOMzrLc8JPfiZxRqegPkYV6BQ8H7PQD352V3/fHTZ399v1S6dx/PJt9/C62e8+Ll//ec7f3B822+3m6fb5sH9YP74d1rfb/cPxu5X6+PNdd8MzOoVjWU6XXt90U8unhO50GbrL1FntLP8L",
-      "brillig_names": [
-        "set_portal"
-      ]
-    },
-    {
-      "name": "check_balance",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public",
-        "view"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "fee_limit",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 128
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "206160798890201757": {
+          "6067862452620309358": {
             "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+            "string": "Function balance_of_public can only be called statically"
           },
-          "3219842053230618354": {
+          "6485997221020871071": {
             "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
+            "string": "call to assert_max_bit_size"
           },
-          "5019202896831570965": {
+          "10502589790419500451": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "Function _increase_public_balance can only be called internally"
           },
           "15238796416211288225": {
             "error_kind": "string",
@@ -2103,10 +1928,10 @@
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBHJwAABAMnAgIEAScCAwQAHxgAAwACgEYdAIBGgEYGLgiARgABJQAAAEwlAAAAYigCAAEEgEcnAgIEADsNAAEAAigAgEMEAAMoAIBEBAAAKACARQQAASYlAAAD0x4CAAMJJwIEAAEKOAMEBSQCAAUAAACDJQAAA/weAgADAS0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBi0MBgctDgQHACgHAgctDgMHJwIDAAAtCAEEJwIGBAQAEAEGAScDBAQBACgEAgYtDAYHLQ4DBwAoBwIHLQ4DBwAoBwIHLQ4DBy0NBAYAKAYCBi0OBgQrAgAGAAAAAAAAAAACAAAAAAAAAAAtCAEHJwIIBAUAEAEIAScDBwQBACgHAggtDAgJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4DCQAoCQIJLQ4GCS0NBAYAKAYCBi0OBgQtCAEGAAABAgEtDgQGLQ0HBAAoBAIELQ4EBy0IAQQAAAECAS0OBwQtCAEHAAABAgEuCoBEAActCAEIAAABAgEnAgkBAC0OCQgnAgoEAi4IgEQAAiMAAAGqDDgCCgskAgALAAACbiMAAAG8LQ0IAgo4AgkFJAIABQAAAdYnAgoEADwJAQonAgIECi0IAAotDAYLLQwEDC0MBw0tDAgOABAAAgAlAAAEDi0EAAAtDQYCLQ0EBS0NBwotDgIGLQ4FBC0OCgcnAgIBAS0OAggBKAAFgEUABC0NBAIKOAIDBAo4BAkDJAIAAwAAAkElAAAFZi8MAAIAAxwMAwQGHAwEAgAcDAIDBgw4AwECCjgCCQEkAgABAAACbSUAAAV4JiQCAAsAAAJ7IwAAA8InAgwEAgw4AgwNJAIADQAAApIlAAAFigAoBQIMADgMAg0tDQ0LLQ0HDC0NCA0KOA0JDiQCAA4AAAK+JwIPBAA8CQEPCygADIBDAA0kAgANAAADTyMAAALTLQ0GDC0NBA0tDQcOLQ0IDycCEQQDDDgOERIkAgASAAAC+iUAAAWKLgQADIADKACABAQABCUAAAWcLgiABQAQACgQAhEAOBEOEi0OCxIBKAAOgEUACw44DgsMJAIADAAAAzolAAAGKi0OEAYtDg0ELQ4LBy0ODwgjAAADwicCDAQNLQgADS0MBg4tDAQPLQwHEC0MCBEAEAAMACUAAAQOLQQAAC0NBgwtDQQNLQ0IDi4EAAyAAygAgAQEAAQlAAAFnC4IgAUADwAoDwIQASgAEIBEABEtDgsRLQ4PBi0ODQQuCoBFAActDg4IIwAAA8IBKAACgEUACy0MCwIjAAABqigAgAQEeAANAAAAgASAAyQAgAMAAAP7KgEAAQX3ofOvpa3UyjwBAQImKgEAAQUsry1Jt6zm8jwBAQImJQAAA9MuCIBEAAUjAAAEHg0oAAWAQwAGJAIABgAABI4jAAAEMy0NAQUtDQIGLQ0DBy0NBAgnAgkEBC0IAQonAgsEBQAQAQsBJwMKBAEAKAYCCycCDAQEACgKAg0/DwALAA0tDQoGACgGAgYtDgYKLQ4FAS0OCgItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEUABiQCAAcAAASsIwAABV0tDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAATTJQAABYoAKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAAAE+CUAAAWKACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAAAFIiUAAAWKLgQACIADKACABAQABSUAAAWcLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAABV0tDAYFIwAABB4qAQABBQLcbieAdhKdPAEBAiYqAQABBdN7FJoYxQChPAEBAiYqAQABBeidCf6hES0OPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAAW3IwAABcIuAIADgAUjAAAGKS4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAAYVLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAAXkKAGABQQAAQMAgAYAAoAGIwAABikmKgEAAQVFp8pxGUHkFTwBAQIm",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "check_balance"
+        "public_dispatch"
       ]
     },
     {
@@ -3762,7 +3587,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -3781,6 +3606,181 @@
         "directive_integer_quotient"
       ],
       "verification_key": "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"
+    },
+    {
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "parameters": [
+          {
+            "name": "_log_ciphertext",
+            "type": {
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec",
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_unique_note_hashes_in_tx",
+            "type": {
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec",
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_recipient",
+            "type": {
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "length": 40,
+            "item_types": []
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
+      "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiTOG/+bJ7kPE30mS9puPAEIDajQgDMYoAs0QKABEg04oQElGqDQALTJGm2yRpus0SYT2mRCm0xokwltMqFNJrTJhDaZ0CYT1OQtpYeJztTe7g2nW0JzKDzzc7Q/3WeMQ2PbJdrcgr4FKL/GUnIl87WzvaIquKhUgiTQCw==",
+      "brillig_names": [
+        "process_log"
+      ]
+    },
+    {
+      "name": "balance_of_public",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "owner",
+            "type": {
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "integer",
+            "sign": "unsigned",
+            "width": 128
+          },
+          "visibility": "public"
+        },
+        "error_types": {
+          "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"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "7Z3bbuM4DIbfJde9EKnzvMpgUfSQKQIESZG2CyyKvvs6mdpuIiEei0KRjP6boo5Fk/osm5REye+Lx+X929PtavNr+7L48fN9sd4+3L2utpvu6P3jZnG/W63Xq6fbrz8v1P4PKT4IvDzfbfbHL693u9fFDzJk1c1iuXk8/O+5u8iv1XrZHbH/uEnKe1Lxs7gntkNpbzKFIzv+LBw5HBX+56azyP+JRebIor0ccaFcoT62ZXJa5eQ0efsppimOUtZmCJJyutdBpEcVLuRKB9cXjmEoq5l+m2Muy5x4UeaYy6JjLouOvSw6NlyUOY4vyxx/UeZ4+m5zbG8OKz4yJ+PPounN8DGOV+aQc2h6uLJhNZbNFeWuUr0VTHy+sOX+unbvdceiB34O/CT8ggI/ET8LfhJ+Ee1Pxg/tT8KPFdqfjJ8BPxG/AH4SfqTBT8TPg5+EHzP4ifih/zbJz/UjqdbRKT+N+EXGD/GzjF8Evyl+Q1l3XHTPz+H5lfEz4Cfih+dXxM+j/cn4of2J+AW0Pxk/jL+I+EX0f2X8MP4i4acV5s9l/DD+IuJH6L/J+GH8RcYP8XMKhTEplIGCSDeFohG+ZqAgJkihGASaGSjw3hkocMkplO/Pkb8GKHDJKRQHl5yBgmGiFArWTuSgwCWnULDKIQcFYX4KBesRclDwTkmgGKwcyEDhNqGwHqEYewpFtxnme+o3Q2CvdXHhPUHTZp9gDkFyY/1coIRgmx2IigRtm06wIsFGc11rEjQgOEXQ+2G/BR8TX9xovmtFgr7NydWaBOGLhQRDmyN/NQkimpEShCcREowGBIUE0QZlBK1CNCMliGhGSJAQzUgJIpqREoQnERJsNOm4JkF4EiHBRtOZaxJsMyliFsFI/cblFDkh+P17Rf91BCvMF1MIvYavM9J5gtb6vnQ36TAyJK1yDJ3vEYbRDPLuYLzV12z8NZN37oqNn87lZOWmjNdxeGu4YxUZc2zocza8UxPfavA69C8kb5jPF+7sGF0MGRW/Fj/U1X97Xf1Y1y9vsrz5jvobRU6Pl9Y6HqwPfNXWXzN71+hqba0GKzSZE3fpGh0+mYCClpJCYQMoKZQ2R37OQ9FoKRkoaCkpFNPmsB9HHqAoO9HdVUPfuKtqSAi2OexXkaBtMwKaRZD0WD9LCcE2w6WKBBtNTa1JsE33WpFgo6mp8wg6O9QvJJ6k0ZSsWQSNGr9sqpI2GNtc7FWPoFdtTmLWJIhoRkiw0W0dZxG0PNTPWpUQbDMlqyLBVtdSVyQIXywkqBFRSwmiVyckaBDNCAlifFBMEGPUQoKNbutXkyDaoJBgoxsGziPoh9RUGzkhiGhGSLDRDzZVJNjoJ4dqEoQnkREMjX52qCZBjA9KCcIXCwkSxgcnCepxqZLWp/MkodFFrzUJwhcLCWr4YilB+GIpQfhiIUHkUYsJIpoRErRog1KCiGaEBB2iGSlBRDNSgohmpgmaYaW2dqczTaHRrzBVJBgwyi8lCF8sJBgRD0oJok8iIxiRyy8liFx+4WqISAYEhQTxHhQSbHTvlooEkct/QrCDQoqzPTU/bPHljU5k8hnp0fSKok31WFUgYwpkwnyZfG7u+U0nup98iVQ+B3NSypVIhSJdoUhXLNIVS3SRoiKpkvtFVKSLiuqVX/E2KWWKpEKJlOYiKT/7HUMmyz2qfjPByBmZ+e8lyj/F5/X4AtvyI2ITMnG+TNDzGYT570yK8/Vw/rmdkJl/T5kK9FCBnvzzGm3frqPnVMbOl9EFevIf3T0vk5+DnpAp0GML9ORn1r7cn4xM3q+fv6fOz5fxBXqCKpCx82ViwbMQ578PtNIFMnG+DJkCmQI9XFAfnt92tKYCmZnt4KM7+vdut7q7Xy9fOon9ybfNw+tqu/k8fP3vuT9zv1ut16un2+fd9mH5+LZb3q63D/tzC/X552fX4G846kME1x3uN82m34f7ynA03VnXae00/w8=",
+      "brillig_names": [
+        "balance_of_public"
+      ]
     }
   ],
   "outputs": {
@@ -3885,30 +3885,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "fee_limit",
-                    "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 128
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "to",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -3919,11 +3896,11 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   },
                   {
-                    "name": "amount",
+                    "name": "initial_mint",
                     "type": {
                       "kind": "integer",
                       "sign": "unsigned",
@@ -3932,12 +3909,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
+                "path": "FeeJuice::initialize_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
+          "path": "FeeJuice::initialize_abi"
         },
         {
           "fields": [
@@ -3984,22 +3961,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
-                    }
-                  },
-                  {
-                    "name": "initial_mint",
+                    "name": "fee_limit",
                     "type": {
                       "kind": "integer",
                       "sign": "unsigned",
@@ -4008,12 +3970,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::initialize_parameters"
+                "path": "FeeJuice::check_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::initialize_abi"
+          "path": "FeeJuice::check_balance_abi"
         },
         {
           "fields": [
@@ -4094,72 +4056,110 @@
           ],
           "kind": "struct",
           "path": "FeeJuice::claim_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "to",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
+                  {
+                    "name": "amount",
+                    "type": {
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 128
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "FeeJuice::_increase_public_balance_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "FeeJuice::_increase_public_balance_abi"
         }
       ]
     }
   },
   "file_map": {
-    "108": {
+    "110": {
       "path": "/home/aztec-dev/aztec-packages/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;\nuse protocol_types::traits::{Hash, ToField};\n\nmod test;\n\npub trait 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        // Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\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_eq(\n            self.state.partial.public_data_tree.root,\n            root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\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 = 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"
     },
-    "117": {
+    "119": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
       "source": "use crate::{\n    discovery::private_notes::MAX_NOTE_PACKED_LEN,\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{\n            stub_registry,\n            utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n        },\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    find_and_transform_top_level_unconstrained_fns(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform message discovery, resulting in new private notes, partial notes and events.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n                // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n                // the unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_ciphertext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    let message_discovery_call = create_message_discovery_call();\n    quote {\n        unconstrained fn sync_notes() {\n            // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n            // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n            // unconstrained execution context since it will not be available otherwise.\n            let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n            $message_discovery_call\n        }\n    }\n}\n"
     },
-    "118": {
+    "120": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
       "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = m.functions();\n    let functions =\n        functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n    let unit = get_type::<()>();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let name = function.name();\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n\n        let mut parameters_size = 0;\n        for param in parameters {\n            parameters_size += size_in_fields(param.1);\n        }\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        let args = args.join(quote { , });\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public\n            // functions having this attribute. However, the public MACRO will\n            // handle the public_dispatch function specially and do nothing.\n            #[public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n    let size = array_size_in_fields(typ);\n    let size = size.or_else(|| bool_size_in_fields(typ));\n    let size = size.or_else(|| constant_size_in_fields(typ));\n    let size = size.or_else(|| field_size_in_fields(typ));\n    let size = size.or_else(|| int_size_in_fields(typ));\n    let size = size.or_else(|| str_size_in_fields(typ));\n    let size = size.or_else(|| struct_size_in_fields(typ));\n    let size = size.or_else(|| tuple_size_in_fields(typ));\n    if size.is_some() {\n        size.unwrap()\n    } else {\n        panic(f\"Can't determine size in fields of {typ}\")\n    }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_array().and_then(|typ: (Type, Type)| {\n        let (typ, element_size) = typ;\n        element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n    })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_bool() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_field() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.as_integer().is_some() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n        let struct_type = typ.0;\n        let generics = typ.1;\n        let mut size = 0;\n        for field in struct_type.fields(generics) {\n            size += size_in_fields(field.1);\n        }\n        size\n    })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_tuple().map(|types: [Type]| {\n        let mut size = 0;\n        for typ in types {\n            size += size_in_fields(typ);\n        }\n        size\n    })\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
     },
-    "125": {
+    "127": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
       "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n        module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n    // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n    // the fallback case for a function that matches no other rules.\n    // TODO(#12743): improve this\n\n    // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n    // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n    // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n    let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n        !is_fn_private(f)\n            & !is_fn_public(f)\n            & !f.has_named_attribute(\"contract_library_method\")\n            & !f.has_named_attribute(\"test\")\n    });\n\n    // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n    // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n    // output of utils such as `nargo test --list-tests`.\n    // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n    // // #[private] macro, possibly resulting in a non-standard interface).\n    // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n    //     !f.is_unconstrained()\n    // }) {\n    //     let name = f.name();\n    //     warn(\n    //         f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n    //     );\n    // }\n\n    // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n    // appropriate transformation. Ideally these would be explicitly designated as such instead.\n    for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n        f.is_unconstrained()\n    }) {\n        transform_top_level_unconstrained(f);\n    }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n"
     },
-    "128": {
+    "130": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
       "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n    UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n    // This macro performs three things:\n    //  - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n    //    functions will have the storage variable injected and initialized via the `init` function.\n    //  - it implements said `init` function by allocating appropriate storage slots to each state variable.\n    //  - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n    //    macro.\n    let mut slot: u32 = 1;\n    let mut storage_vars_constructors = &[];\n    let mut storage_layout_fields = &[];\n    let mut storage_layout_constructors = &[];\n\n    // TODO(#8658): uncomment the code below to inject the Context type parameter.\n    //let mut new_storage_fields = &[];\n    //let context_generic = s.add_generic(\"Context\");\n    for field in s.fields_as_written() {\n        // FIXME: This doesn't handle field types with generics\n        let (name, typ) = field;\n        let (storage_field_constructor, storage_size) =\n            generate_storage_field_constructor(typ, quote { $slot }, false);\n        storage_vars_constructors =\n            storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n        // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n        // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n        // a contract.\n        storage_layout_fields =\n            storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n        storage_layout_constructors = storage_layout_constructors.push_back(\n            quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n        );\n        //let with_context_generic = add_context_generic(typ, context_generic);\n        //println(with_context_generic);\n        //new_storage_fields = new_storage_fields.push_back((name,  with_context_generic ));\n        slot += storage_size;\n    }\n\n    //s.set_fields(new_storage_fields);\n    let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n    let storage_impl = quote {\n        impl<Context> Storage<Context> {\n            fn init(context: Context) -> Self {\n                Self {\n                    $storage_vars_constructors\n                }\n            }\n        }\n    };\n\n    let storage_layout_fields = storage_layout_fields.join(quote {,});\n    let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n    let module = s.module();\n    let module_name = module.name();\n    let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n    let (module_name_str, module_name_len) = module_name.as_str_quote();\n    STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n    quote {\n        $storage_impl\n\n        pub struct StorageLayoutFields {\n            $storage_layout_fields\n        }\n\n        pub struct StorageLayout<let N: u32> {\n            pub contract_name: str<N>,\n            pub fields: StorageLayoutFields\n        }\n\n        #[abi(storage)]\n        pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n            contract_name: $module_name_str,\n            fields: StorageLayoutFields { $storage_layout_constructors }\n        };\n    }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n    // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n    // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n    // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n    typ: Type,\n    slot: Quoted,\n    parent_is_map: bool,\n) -> (Quoted, u32) {\n    assert(\n        typ.as_data_type().is_some(),\n        \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n    );\n    let (container_struct, generics) = typ.as_data_type().unwrap();\n    let struct_name = container_struct.name();\n\n    if is_storage_map(typ) {\n        // Map state variables recursively initialize their contents - this includes nested maps.\n        let (value_constructor, _) =\n            generate_storage_field_constructor(generics[1], quote { slot }, true);\n        (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n    } else {\n        let storage_size = if parent_is_map {\n            // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n            // in slots very far away from one another.\n            1\n        } else {\n            let (_, container_struct_generics) = typ.as_data_type().unwrap();\n            let stored_struct = container_struct_generics[0];\n\n            if is_note(stored_struct) {\n                // Private notes always occupy a single slot, since the slot is only used as a state variable\n                // identifier.\n                1\n            } else {\n                get_storage_size(typ)\n            }\n        };\n\n        // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n        (quote { $struct_name::new(context, $slot)}, storage_size)\n    }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n    if typ.as_data_type().is_some() {\n        let (def, generics) = typ.as_data_type().unwrap();\n        let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n            let maybe_key = generics[0];\n            let maybe_value = generics[1];\n            let maybe_context = generics[2];\n            quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n        } else {\n            quote {()}.as_type()\n        };\n        typ == maybe_map\n    } else {\n        false\n    }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n    let (def, mut generics) = typ.as_data_type().expect(\n        f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n    );\n    let name = def.name();\n\n    if is_storage_map(typ) {\n        generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n        generics[generics.len() - 1] = context_generic;\n    } else {\n        generics[generics.len() - 1] = context_generic;\n    }\n\n    let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n    quote { $name<$generics> }.as_type()\n}\n"
     },
-    "130": {
+    "132": {
       "path": "/home/aztec-dev/aztec-packages/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    // Safety: The witness is only used as a \"magical value\" that makes the merkle proof below pass. Hence it's safe.\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_eq(root, l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
-    "147": {
+    "149": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T, let N: u32>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize<N>,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T, let N: u32>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize<N>,\n{\n    let serialized_option = load_oracle::<N>(contract_address, slot, N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    unconstrained fn setup() -> AztecAddress {\n        let env = TestEnvironment::new();\n        env.contract_address()\n    }\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), value);\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        let new_value = MockStruct::new(7, 8);\n        store(contract_address, SLOT, new_value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let contract_address = setup();\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n        delete(contract_address, SLOT);\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let contract_address = setup();\n\n        delete(contract_address, SLOT);\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let contract_address = setup();\n\n        let src = 5;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 10;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let contract_address = setup();\n\n        let src = 1;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 2;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n        assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n        assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let contract_address = setup();\n\n        let src = 2;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 1;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n        assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n        assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let contract_address = setup();\n\n        copy(contract_address, SLOT, SLOT, 1);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let value = MockStruct::new(5, 6);\n        store(other_contract_address, SLOT, value);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let _: Option<MockStruct> = load(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        delete(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        copy(other_contract_address, SLOT, SLOT, 0);\n    }\n}\n"
     },
-    "148": {
+    "150": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_enqueued_public_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_enqueued_public_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_enqueued_public_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_set_public_teardown_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_public_teardown_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_set_public_teardown_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\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"
     },
-    "149": {
+    "151": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "150": {
+    "152": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n    store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "152": {
+    "154": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use 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    get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret)\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, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {}\n"
     },
-    "155": {
+    "157": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
       "source": "use dep::protocol_types::{constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage};\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(getPublicDataWitness)]\nunconstrained fn get_public_data_witness_oracle(\n    _block_number: u32,\n    _public_data_tree_index: Field,\n) -> PublicDataWitness {}\n\npub unconstrained fn get_public_data_witness(\n    block_number: u32,\n    public_data_tree_index: Field,\n) -> PublicDataWitness {\n    get_public_data_witness_oracle(block_number, public_data_tree_index)\n}\n"
     },
-    "159": {
+    "161": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr",
       "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {\n    deliver_note_oracle(\n        contract_address,\n        storage_slot,\n        nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n        recipient,\n    )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n    pub log_content: BoundedVec<Field, PUBLIC_LOG_DATA_SIZE_IN_FIELDS>,\n    pub tx_hash: Field,\n    /// The array of new note hashes created by `tx_hash`\n    pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    /// The first nullifier created by `tx_hash`\n    pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option<LogWithTxData> {\n    get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option<LogWithTxData> {}\n"
     },
-    "161": {
+    "163": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{\n    note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n    utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    traits::{Deserialize, FromField, Packable},\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    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: 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) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: 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) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n    // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n    // the oracle, so that it knows how big the return array must be.\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        ORACLE_RETURN_FIELD_LENGTH,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let MAX_NOTES: u32, let ORACLE_RETURN_FIELD_LENGTH: 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    _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n    Note: NoteType + Packable<N>,\n{\n    let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = 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    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n\n    let mut opt_notes = [Option::none(); MAX_NOTES];\n    for i in 0..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 maybe_nonce = fields[read_offset];\n            let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n            let packed_note = array::subarray(fields, read_offset + 2);\n\n            let note = Note::unpack(packed_note);\n            let retrieved_note = RetrievedNote {\n                note,\n                contract_address,\n                metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n            };\n\n            opt_notes[i] = Option::some(retrieved_note);\n        };\n    }\n    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)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // 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"
+      "source": "use crate::{\n    note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n    utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::IndexedTaggingSecret,\n    traits::{FromField, Packable},\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    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: 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) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: 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) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n    // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n    // the oracle, so that it knows how big the return array must be.\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        ORACLE_RETURN_FIELD_LENGTH,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let MAX_NOTES: u32, let ORACLE_RETURN_FIELD_LENGTH: 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    _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n    Note: NoteType + Packable<N>,\n{\n    let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = 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    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n\n    let mut opt_notes = [Option::none(); MAX_NOTES];\n    for i in 0..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 maybe_nonce = fields[read_offset];\n            let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n            let packed_note = array::subarray(fields, read_offset + 2);\n\n            let note = Note::unpack(packed_note);\n            let retrieved_note = RetrievedNote {\n                note,\n                contract_address,\n                metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n            };\n\n            opt_notes[i] = Option::some(retrieved_note);\n        };\n    }\n    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)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // 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"
     },
-    "164": {
+    "166": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
       "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n    address: Field,\n    storage_slot: Field,\n    block_number: Field,\n    length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> [Field; N] {\n    storage_read_oracle(\n        address.to_field(),\n        storage_slot,\n        block_number as Field,\n        N as Field,\n    )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> T\nwhere\n    T: Packable<N>,\n{\n    T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n    use crate::oracle::storage::{raw_storage_read, storage_read};\n    use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n    use crate::test::mocks::mock_struct::MockStruct;\n    use std::test::OracleMock;\n\n    global address: AztecAddress = AztecAddress::from_field(29);\n    global slot: Field = 7;\n    global block_number: u32 = 17;\n\n    #[test]\n    unconstrained fn test_raw_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n        assert_eq(read[0], 13);\n        assert_eq(read[1], 42);\n    }\n\n    #[test]\n    unconstrained fn test_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: MockStruct = storage_read(address, slot, block_number);\n        assert_eq(read.a, 13);\n        assert_eq(read.b, 42);\n    }\n}\n"
     },
-    "166": {
+    "168": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
       "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\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<N> for Map<K, T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\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"
     },
@@ -4167,11 +4167,11 @@
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
-    "173": {
+    "175": {
       "path": "/home/aztec-dev/aztec-packages/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    utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash<T>` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n///     pub address_1: AztecAddress,\n///     pub value_1: u128,\n///     pub value_2: u64,\n///     ...\n/// }\n/// ```\n///\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\n/// `WithHash<T>` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl<T, Context, let M: u32, let N: u32> Storage<N> for PublicImmutable<T, Context>\nwhere\n    WithHash<T, M>: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\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_PACKED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\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, WithHash::new(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        WithHash::public_storage_read(*self.context, self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\n{\n    pub unconstrained fn read(self) -> T {\n        WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n    }\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\n{\n    pub fn read(self) -> T {\n        WithHash::historical_public_storage_read(\n            self.context.get_block_header(),\n            self.context.this_address(),\n            self.storage_slot,\n        )\n    }\n}\n"
     },
-    "174": {
+    "176": {
       "path": "/home/aztec-dev/aztec-packages/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::Packable;\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<N> for PublicMutable<T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\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_PACKED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Packable<T_PACKED_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_PACKED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Packable<T_PACKED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
@@ -4179,23 +4179,23 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(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..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "188": {
+    "190": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let A_LEN: u32, let B_LEN: u32, let DST_LEN: u32>(\n    a: BoundedVec<T, A_LEN>,\n    b: BoundedVec<T, B_LEN>,\n) -> BoundedVec<T, DST_LEN> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "190": {
+    "192": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr",
       "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec<T, let MaxLen: u32, Env>(\n    vec: BoundedVec<T, MaxLen>,\n    f: fn[Env](T, u32) -> (),\n) {\n    for i in 0..vec.len() {\n        f(vec.get_unchecked(i), i);\n    }\n}\n"
     },
-    "191": {
+    "193": {
       "path": "/home/aztec-dev/aztec-packages/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 not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; 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::<Field, _, _>([], 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::<Field, _, _>([], 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_with = \"DST_LEN too large for offset\")]\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"
     },
-    "192": {
+    "194": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n    bvec: BoundedVec<T, SRC_MAX_LEN>,\n    offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "203": {
+    "205": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
       "source": "use crate::{\n    context::{PublicContext, UnconstrainedContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn unconstrained_public_storage_read(\n        context: UnconstrainedContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::protocol_types::traits::{Packable, ToField};\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
     },
@@ -4203,63 +4203,63 @@
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "264": {
+    "266": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::{pow, sqrt},\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 std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\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\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\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 secret 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_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\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_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as 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\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"
     },
-    "265": {
+    "267": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
       "source": "use crate::{\n    constants::ETH_ADDRESS_LENGTH,\n    traits::{Deserialize, Empty, Packable, Serialize, ToField},\n};\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 Packable<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn pack(self) -> [Field; ETH_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\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"
     },
-    "279": {
+    "281": {
       "path": "/home/aztec-dev/aztec-packages/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, LeafPreimage},\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 LeafPreimage for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\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 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"
     },
-    "281": {
+    "283": {
       "path": "/home/aztec-dev/aztec-packages/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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // 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"
     },
-    "282": {
+    "284": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "292": {
+    "294": {
       "path": "/home/aztec-dev/aztec-packages/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"
     },
-    "296": {
+    "298": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
       "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n    typ: Type,\n    target_trait: Quoted,\n    target_method: Quoted,\n) -> TypedExpr {\n    let trait_constraint = target_trait.as_trait_constraint();\n    typ\n        .get_trait_impl(trait_constraint)\n        .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n        .methods()\n        .filter(|m| m.name() == target_method)[0]\n        .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n///     value: u128,\n///     owner: AztecAddress,\n///     randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n///     inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n///     value: fields[0] as u128,\n///     owner: AztecAddress {\n///         inner: fields[1],\n///     },\n///     randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n///   the result we get is:\n/// ```\n/// UintNote {\n///     value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n///     owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n///     randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n    name: Quoted,\n    typ: Type,\n    field_array_name: Quoted,\n    num_already_consumed: u32,\n    should_unpack: bool,\n) -> (Quoted, u32) {\n    let mut result = quote {};\n    // Counter for the number of fields consumed\n    let mut consumed_counter: u32 = 0;\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_unpack & typ.implements(packable_constraint)) {\n        // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We copy the packed fields into a new array and pass that to the unpack function in a quote\n        let mut packed_fields_quotes = &[];\n        for i in 0..packed_len {\n            let index_in_field_array = i + num_already_consumed;\n            packed_fields_quotes =\n                packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n        }\n        let packed_fields = packed_fields_quotes.join(quote {,});\n\n        // Now we call unpack on the type\n        let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n        result = quote { $unpack_method([ $packed_fields ]) };\n\n        consumed_counter = packed_len;\n    } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] as $typ };\n        consumed_counter = 1;\n    } else if typ.as_data_type().is_some() {\n        // The field is a struct so we iterate over each struct field and recursively call\n        // `generate_deserialize_from_fields`\n        let (nested_def, generics) = typ.as_data_type().unwrap();\n        let nested_name = nested_def.name();\n        let mut deserialized_fields_list = &[];\n\n        // Iterate over each field in the struct\n        for field in nested_def.fields(generics) {\n            let (field_name, field_type) = field;\n            // Recursively call `generate_deserialize_from_fields` for each field in the struct\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                field_name,\n                field_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n            deserialized_fields_list =\n                deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n        }\n\n        // We can construct the struct from the deserialized fields\n        let deserialized_fields = deserialized_fields_list.join(quote {,});\n        result = quote {\n                $nested_name {\n                    $deserialized_fields\n                }\n            };\n    } else if typ.as_array().is_some() {\n        // The field is an array so we iterate over each element and recursively call\n        // `generate_deserialize_from_fields`\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        let mut array_fields_list = &[];\n\n        // Iterate over each element in the array\n        for _ in 0..array_len {\n            // Recursively call `generate_deserialize_from_fields` for each element in the array\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                element_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            array_fields_list = array_fields_list.push_back(deserialized_field);\n        }\n\n        // We can construct the array from the deserialized fields\n        let array_fields = array_fields_list.join(quote {,});\n        result = quote { [ $array_fields ] };\n    } else if typ.as_str().is_some() {\n        // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n        // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n        // to `generate_deserialize_from_fields`.\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let mut byte_list = &[];\n\n        // Iterate over each character in the string\n        for _ in 0..str_len {\n            // Recursively call `generate_deserialize_from_fields` for each character in the string\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                quote {u8}.as_type(),\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n\n            // We should consume just one field in the recursion so we sanity check that\n            assert_eq(\n                num_consumed_in_recursion,\n                1,\n                \"Incorrect number of fields consumed in string deserialization\",\n            );\n\n            // We increment the consumed counter by 1 as we have consumed one field\n            consumed_counter += 1;\n\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `fields[6] as u8`\n            byte_list = byte_list.push_back(deserialized_field);\n        }\n\n        // We construct the string from the deserialized fields\n        let bytes = byte_list.join(quote {,});\n        result = quote { [ $bytes ].as_str_unchecked() };\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    omit: [Quoted],\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // Proceed if none of the omit rules omits this name\n    if !omit.any(|to_omit| to_omit == name) {\n        // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n        let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n        let packable_constraint =\n            quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n        if (should_pack & typ.implements(packable_constraint)) {\n            // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n            // method, add the resulting field array to `aux_vars` and each field to `fields`.\n            let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n            // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n            let name_at_one_token = collapse_to_one_token(name);\n            let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n            // We add the individual fields to the fields array\n            let pack_method = get_trait_impl_method(\n                typ,\n                quote { crate::traits::Packable<$packed_len> },\n                quote { pack },\n            );\n            let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n            for i in 0..packed_len {\n                fields = fields.push_back(quote { $packed_struct_name[$i] });\n            }\n\n            // We add the new auxiliary variable to the aux_vars array\n            aux_vars = aux_vars.push_back(packed_struct);\n        } else if typ.is_field() {\n            // For field we just add the value to fields\n            fields = fields.push_back(name);\n        } else if typ.as_integer().is_some() | typ.is_bool() {\n            // For integer and bool we just cast to Field and add the value to fields\n            fields = fields.push_back(quote { $name as Field });\n        } else if typ.as_data_type().is_some() {\n            // For struct we pref\n            let nested_struct = typ.as_data_type().unwrap();\n            let params = nested_struct.0.fields(nested_struct.1);\n            let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n                let maybe_prefixed_name = if name == quote {} {\n                    // Triggered when the param name is of a value available in the current scope (e.g. a function\n                    // argument) --> then we don't prefix the name with anything.\n                    param_name\n                } else {\n                    // Triggered when we want to prefix the param name with the `name` from function input. This\n                    // can typically be `self` when implementing a method on a struct.\n                    quote { $name.$param_name }\n                };\n                generate_serialize_to_fields(\n                    quote {$maybe_prefixed_name},\n                    param_type,\n                    omit,\n                    should_pack,\n                )\n            });\n            let struct_flattened_fields = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n            );\n            let struct_flattened_aux_vars = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n            );\n            fields = fields.append(struct_flattened_fields);\n            aux_vars = aux_vars.append(struct_flattened_aux_vars);\n        } else if typ.as_array().is_some() {\n            // For array we recursively call `generate_serialize_to_fields(...)` for each element\n            let (element_type, array_len) = typ.as_array().unwrap();\n            let array_len = array_len.as_constant().unwrap();\n            for i in 0..array_len {\n                let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n                    quote { $name[$i] },\n                    element_type,\n                    omit,\n                    should_pack,\n                );\n                fields = fields.append(element_fields);\n                aux_vars = aux_vars.append(element_aux_vars);\n            }\n        } else if typ.as_str().is_some() {\n            // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n            // then we add each byte to fields as a Field\n            let length_type = typ.as_str().unwrap();\n            let str_len = length_type.as_constant().unwrap();\n            let as_member = name.as_expr().unwrap().as_member_access();\n            let var_name = if as_member.is_some() {\n                as_member.unwrap().1\n            } else {\n                name\n            };\n            let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n            let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n            for i in 0..str_len {\n                fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n            }\n            aux_vars = aux_vars.push_back(as_bytes);\n        } else {\n            panic(\n                f\"Unsupported type for serialization of argument {name} and type {typ}\",\n            )\n        }\n    }\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    quote {\n        impl Serialize<$serialized_len> for $typ {\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) =\n        generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
     },
-    "299": {
+    "301": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "319": {
+    "321": {
       "path": "/home/aztec-dev/aztec-packages/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, traits::FromField};\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"
     },
-    "337": {
+    "339": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
       "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable<BOOL_PACKED_LEN> for bool {\n    fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Packable<U8_PACKED_LEN> for u8 {\n    fn pack(self) -> [Field; U8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable<U16_PACKED_LEN> for u16 {\n    fn pack(self) -> [Field; U16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable<U32_PACKED_LEN> for u32 {\n    fn pack(self) -> [Field; U32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable<U64_PACKED_LEN> for u64 {\n    fn pack(self) -> [Field; U64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable<U128_PACKED_LEN> for u128 {\n    fn pack(self) -> [Field; U128_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable<FIELD_PACKED_LEN> for Field {\n    fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n        [self]\n    }\n\n    fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable<I8_PACKED_LEN> for i8 {\n    fn pack(self) -> [Field; I8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Packable<I16_PACKED_LEN> for i16 {\n    fn pack(self) -> [Field; I16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Packable<I32_PACKED_LEN> for i32 {\n    fn pack(self) -> [Field; I32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Packable<I64_PACKED_LEN> for i64 {\n    fn pack(self) -> [Field; I64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Packable<N * M> for [T; N]\nwhere\n    T: Packable<M>,\n{\n    fn pack(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].pack();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    fn unpack(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>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
     },
-    "338": {
+    "340": {
       "path": "/home/aztec-dev/aztec-packages/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 as Field]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for u128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        fields[0] as u128\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"
     },
-    "354": {
+    "356": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
       "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & !is_empty(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let index = find_last_value_index(array);\n    if index == N {\n        0\n    } else {\n        index + 1\n    }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid right padded array\");\n        }\n    }\n    length\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(padded_array_length(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
-    "355": {
+    "357": {
       "path": "/home/aztec-dev/aztec-packages/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\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\npub(crate) fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\npub(crate) fn sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\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"
     },
-    "357": {
+    "359": {
       "path": "/home/aztec-dev/aztec-packages/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"
     },
-    "363": {
+    "365": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n    BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n    INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\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// 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    assert(message_size <= N);\n\n    if std::runtime::is_unconstrained() {\n        // Safety: SHA256 is running as an unconstrained function.\n        unsafe {\n            __sha256_var(msg, message_size)\n        }\n    } else {\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 = INITIAL_STATE;\n        // Pointer into msg_block on a 64 byte scale\n        let mut msg_byte_ptr = 0;\n        let num_blocks = N / BLOCK_SIZE;\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            // 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\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            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        }\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        let index = msg_byte_ptr / INT_SIZE;\n        msg_block[index] = set_item_byte_then_zeros(msg_block[index], 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        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n        hash_final_block(msg_block, h)\n    }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var<let N: u32>(msg: [u8; N], message_size: u32) -> HASH {\n    let num_full_blocks = message_size / BLOCK_SIZE;\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = INITIAL_STATE;\n    // Pointer into msg_block on a 64 byte scale\n    for i in 0..num_full_blocks {\n        let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n        h = sha256_compression(msg_block, h);\n    }\n\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    let modulo = message_size % BLOCK_SIZE;\n    let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_full_blocks;\n        let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n        (new_msg_block, new_msg_byte_ptr)\n    } else {\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        ([0; INT_BLOCK_SIZE], 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    let index = msg_byte_ptr / INT_SIZE;\n    msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n    // If we don't have room to write the size, compress the block and reset it.\n    let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        (sha256_compression(msg_block, h), 0)\n    } else {\n        (h, msg_byte_ptr + 1)\n    };\n    msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\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 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 if message_size < msg_start + BLOCK_SIZE {\n        message_size - msg_start\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// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\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].\n#[inline_always]\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.\n#[inline_always]\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.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        // Brillig wouldn't shift 0<<4 without overflow.\n        if shifts >= 4 {\n            0\n        } else {\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 equivalence_test {\n\n    #[test]\n    fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n        let message_size = message_size % 100;\n        let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n        let sha = super::sha256_var(msg, message_size);\n        assert_eq(sha, unconstrained_sha);\n    }\n}\n"
     },
@@ -4309,7 +4309,7 @@
     },
     "78": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr",
-      "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n    PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n///         Option::some(\n///             aztec::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    private_logs::fetch_and_process_private_tagged_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    partial_notes::fetch_and_process_public_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n}\n"
+      "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n    PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n///         Option::some(\n///             aztec::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    private_logs::fetch_and_process_private_tagged_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    partial_notes::fetch_and_process_public_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n}\n"
     },
     "79": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr",
@@ -4321,9 +4321,9 @@
     },
     "81": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr",
-      "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n    debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n    ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n    partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n    private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n    _contract_address: AztecAddress,\n    _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n    // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n    // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n    // decrypted log, letting us continue the work outside of PXE.\n    sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log<Env>(\n    contract_address: AztecAddress,\n    log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n    let log_plaintext = decrypt_log(log, recipient);\n\n    // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n    // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n    // improved upon in the future to also handle events, etc.\n\n    let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n    if log_type_id == 0 {\n        debug_log(\"Processing private note log\");\n\n        process_private_note_log(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            recipient,\n            compute_note_hash_and_nullifier,\n            log_metadata,\n            log_content,\n        );\n    } else if log_type_id == 1 {\n        debug_log(\"Processing partial note private log\");\n\n        process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n    } else {\n        // TODO(#11569): handle events\n        debug_log_format(\n            \"Unknown log type id {0} (probably belonging to an event log)\",\n            [log_type_id as Field],\n        );\n    }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n///  - an initial field called the 'expanded metadata'\n///  - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n///  - the upper 57 bits are the log type id\n///  - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [  log_type_id   |  log_metadata ]\n///                        <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (u64, u64, BoundedVec<Field, MAX_LOG_CONTENT_LEN>) {\n    assert(\n        log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the log encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n    );\n\n    // See the documentation of this function for a description of the log layout\n    let expanded_log_metadata = log_plaintext.get(0);\n\n    let log_type_id = ((expanded_log_metadata as u64) / 128);\n    let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n    let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n    (log_type_id, log_metadata, log_content)\n}\n"
+      "source": "use crate::{\n    discovery::{\n        ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n        partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        private_notes::process_private_note_log,\n    },\n    encrypted_logs::{\n        log_assembly_strategies::default_aes128::aes128::AES128,\n        log_encryption::LogEncryption,\n        log_type::{PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID},\n        metadata_packing::from_expanded_metadata,\n    },\n    oracle::message_discovery::sync_notes,\n    utils::array,\n};\n\nuse protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n    debug_log::{debug_log, debug_log_format},\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n    _contract_address: AztecAddress,\n    _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n    // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n    // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n    // decrypted log, letting us continue the work outside of PXE.\n    sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log<Env>(\n    contract_address: AztecAddress,\n    log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n    // The tag is ignored for now.\n    let ciphertext = array::subbvec(log, 1);\n\n    let log_plaintext = AES128::decrypt_log(ciphertext, recipient);\n\n    // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n    // have 3 log types: private note logs, partial note logs and event logs.\n\n    let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n    if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n        debug_log(\"Processing private note log\");\n\n        process_private_note_log(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            recipient,\n            compute_note_hash_and_nullifier,\n            log_metadata,\n            log_content,\n        );\n    } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n        debug_log(\"Processing partial note private log\");\n\n        process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n    } else {\n        // TODO(#11569): handle events\n        debug_log_format(\n            \"Unknown log type id {0} (probably belonging to an event log)\",\n            [log_type_id as Field],\n        );\n    }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n///  - an initial field called the 'expanded metadata'\n///  - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n///  - the upper 64 bits are the log type id\n///  - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [  log_type_id    |  log_metadata  ]\n///                        <---  64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (u64, u64, BoundedVec<Field, MAX_LOG_CONTENT_LEN>) {\n    assert(\n        log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the log encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n    );\n\n    // See the documentation of this function for a description of the log layout\n    let expanded_log_metadata = log_plaintext.get(0);\n    let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n    let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n    (log_type_id, log_metadata, log_content)\n}\n"
     },
-    "96": {
+    "98": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__PUBLIC_CALLDATA, 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, ToField},\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_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\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\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\n// Same as `hash_args_array`, but takes a slice instead of an array.\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// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\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"
     }