@aztec/protocol-contracts 0.84.0-nightly.20250410 → 0.84.0-nightly.20250412

package/artifacts/FeeJuice.json

@@ -1,19 +1,19 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
   "name": "FeeJuice",
   "functions": [
     {
-      "name": "_increase_public_balance",
+      "name": "balance_of_public",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "internal"
+        "view"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "to",
+            "name": "owner",
             "type": {
               "kind": "struct",
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
@@ -27,18 +27,16 @@
               ]
             },
             "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 128
-            },
-            "visibility": "private"
           }
         ],
-        "return_type": null,
+        "return_type": {
+          "abi_type": {
+            "kind": "integer",
+            "sign": "unsigned",
+            "width": 128
+          },
+          "visibility": "public"
+        },
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -48,13 +46,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "16761564377371454734": {
+          "6067862452620309358": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Function balance_of_public can only be called statically"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -62,27 +56,24 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACSR4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAnInAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGLQ0EBQAoBQIFLQ4FBCsCAAUAAAAAAAAAAAIAAAAAAAAAAC0IAQYnAgcEBQAQAQcBJwMGBAEAKAYCBy0MBwgtDgIIACgIAggtDgIIACgIAggtDgIIACgIAggtDgUILQ0EBQAoBQIFLQ4FBC0NBgUAKAUCBS0OBQYtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAAChC0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAoQtBAAALQ0HAQsoAAGARAADJAIAAwAAAeInAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADmC0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIzJQAABKsvDAADAAEcDAEDBhwMAwIAHAwCAQYmKACABAR4AA0AAACABIADJACAAwAAAnEqAQABBfeh86+lrdTKPAEBAiYqAQABBVQ1YMByXTNuPAEBAiYlAAACSS0NAwYtDQQHCygAB4BEAAgkAgAIAAACqicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAyQjAAACvy0NAQYtDQIHLQ0DCC0NBAkuBAAGgAMoAIAEBAAEJQAABL0uCIAFAAoAKAoCCwA4CwgMLQ4FDAEoAAiARgAFDjgIBQYkAgAGAAADDyUAAAVLLQ4KAS0OBwItDgUDLQ4JBCMAAAOXJwIGBActCAAHLQwBCC0MAgktDAMKLQwECwAQAAYAJQAAA5gtBAAALQ0BBi0NAgctDQQILgQABoADKACABAQABCUAAAS9LgiABQAJACgJAgoBKAAKgEUACy0OBQstDgkBLQ4HAi4KgEYAAy0OCAQjAAADlyYlAAACSS4IgEUABSMAAAOoDSgABYBDAAYkAgAGAAAEGCMAAAO9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARgAGJAIABwAABDYjAAAEoi0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAABL0uCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAEoi0MBgUjAAADqCoBAAEFAtxuJ4B2Ep08AQECJi4BgAOABgsAgAYAAoAHJACABwAABNgjAAAE4y4AgAOABSMAAAVKLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABTYuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABQUoAYAFBAABAwCABgACgAYjAAAFSiYqAQABBUWnynEZQeQVPAEBAiY=",
+      "debug_symbols": "7Z3ZbuM6DIbfJde5EClqm1c5OBh0SQcBgrRI2wMcFH33cYJ4icVYNRXMAvNmMJ7hb0mfJZGiYutj9bi5f//xfbt/en5dffvnY7V7frh72z7vm6uPz/Xq/rDd7bY/vg//eWWOf4BJJ8Hry93+eP36dnd4W30DdAjr1Wb/ePo72eYmT9vdprky7nOd2YfmPmfz0Nh31sEwxgk9no0Txgvjf9crAPpKjdxFjU66JNOhsDyLQl3gdGi8P8vQDKA4YAiC8bYtA2DwcDxx1q6/M3a2Fj33IBO59kGm1N8ZY2KsbTBnY7LU23IPHRHaGyNaO23sKJxtHcWh6ZEfofKr4ueVXw0/B8qvip/2vyp+XvtfHT/tf1X8glF+VfxI+VXxS8qvhl+0yq+KX1R+NfySrt+K/GKbQnARM34av9TwQ6Pxcx0/p/wK/Hxn6y9Nj/xQx28VP6vrjzp+On6r+JH2vzp+2v+q+Dntf3X8SPlV8dP1bxU/r/mXOn66f17FL2j+pY6frt+q+EXNv9Tx0/iZgaKbQjmURAolh6LhawbFGo0JGCgaaOZQQL03A0Vdcg4FNU/FQFGXzEBRl5xDsZomYqCoS86hkLpkBopmaXIoTsN8Bor2lByKvmTAQVmm97HQVhlPRV9CWeh2QgHKMueUaShxmQvCAhRSKDmUZS4Ip6Es9HfzBSg60WZQaKG/cC9A0Z6SQwF1yQyUZWbzC1CWucE+DQWXmaMtQNFVcg7FqktmoOhEy0DRiTaHQqRQcijaU3IobpkuOVBri8HJjU8El+m/5xAEH6ltXzDjN6TJL9Ov3ZBg0FFcS3CZKdQbEozLzLfOIhhS+6EXiJD54qiepJJgWuay8ZYE1RfXElzmMuN2BJ3RaKaWoHqSSoKg0UwtQe2DlQRRo5laghrNFAkm27UvUUZwoa9V3JLgDeZBiLEtAYdHZLAEnUtt5X3EvvJgIsfQt98uDKH/9igEe6r8LQ6P+G2Vv8WXn35f5eNfXPkvfLMnhVLlu7ENcDwXZ1AEUx3X5aaCN4UDdYKN7YANhDht3MxYwXcVIZOG5qe2pl/e1tC3FU2h+h46B+kH054lOtX+C19X/5Nr/zez9/yGJJjO9zRDL43ciec37Eoi1gcBOOqbPk7oen5bpiDidyJKoigQ8fnmZs7rRiuaMYjApxaA+jOohhNCKwoCEf/if0nkJCK+Gznq6LkAYxEfGRdEV47wKoiCQERWIooCkZOUdGU8udQFgh7Gr0OFK+NpWsSfHlISRYEoWolIAoLP0pdEAnrRsN4NbB+wW4eZKAlEYCWiIBDxWYGSyElEEhBWgtxKSiIJcpIgdxLk7gpy38XkNo4nluhBIooC0RVHXRAlgSiSQMS/vVMS+fnuMxkjEZFABJKSLNumZpHThaHjXyQl3julLguTwjhJkfh+Ny1x8yVptiQIwt10xf9Ni67EkwVREIiSpKQkKAmMQZFKVBaIyoIoUaGoLBS1i/8telHlRKokUZEVqeLcmQUM/0WMhO0SOhGjmT0dgeFH8HQ5UVC36OdrkhFoaD6DNHu2BDAk0PCsY9sPLjLrZw0f7hY0gnL4cT5oD6eZ39+A3+aY1vAHWxQ0br7GgUDj52u8oBwvaI8X9OsgeD5hZj/4bK7+uzts7+53m/NB8E/v+4fBufBv/79sRkfEvxyeHzaP74fN8bD4/pz4Y9dAgjV6PI3l5rKp0Lrpz6eqHf+3qQd615TalPwT",
       "brillig_names": [
-        "_increase_public_balance"
+        "balance_of_public"
       ]
     },
     {
-      "name": "check_balance",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "view"
+        "public"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "fee_limit",
+            "name": "selector",
             "type": {
-              "kind": "integer",
-              "sign": "unsigned",
-              "width": 128
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -93,6 +84,15 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
           "3219842053230618354": {
             "error_kind": "string",
             "string": "Function check_balance can only be called statically"
@@ -101,24 +101,54 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
           "15238796416211288225": {
             "error_kind": "string",
             "string": "Balance too low"
           },
-          "16761564377371454734": {
+          "17843811134343075018": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "aztec::macros::functions::utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bbuM4DIbfJde9EKnzvMpgUfSQKQIESZG2CyyKvvs6mdhOIzUei8Ighf6bQT0hTeozbVKyJL8vHpf3b0+3q82v7cvix8/3xXr7cPe62m66o/ePm8X9brVer55uT/97ofb/kNIHhZfnu83++OX1bve6+EFsmW4Wy83j4W+ju5P8Wq2X+6PwcZPIe1LxKO47+UHam4xwZMdH4cjhk/A/N51H4U88sp882uuRLtQrtMeuTE9TVi8416uFYAYtazMETdDmKGyC4cu4g/U97mCDP8et880IZnTH2cvukHK6F+4uw9hiF3PSYThzDIOsZn1wx6jrcsdelTv2uujY66LjrouOM9flTrgqd7y+Lnf833bH9mdmxZ/cyaTXaGyfXmMcz8zBZaT1cGbDapTN5Qam2CcSZuLLwpb781r2p6J7foHBT8TPgZ+EXyTwE/FD/En4sUL8yfgh/kT8SIGfiJ8BPxG/CH4SfqzBT8QvgJ+En0b/bZKfUz0/Rwk/1C8ifgb1s4yfBb8pfoOs+yy65+dw/4r4efQ/ZPxw/4r4BcSfjB/iT8QvIv5k/Az4ifih/yvhpxXGX2T88P5cxI8w/iLjh/6biB9j/EXGD/VzBgpeCqVQtAGUFArK1xSKQU2QgYJCM4Vikb0zUJCSUygO41QZKEjJGShIySkUj2GiDBSk5BRKQErOQMEoTQoloszPQEGkJFAMFhnkoCBSUijcJhTWI5STpfdHKMY0CcVTvzcDe62LhQ8E2+wTzCFIbmyfC+fzNI1tswNRkaBrMwnWJNhmcqhIsNHZrrMIej/A8DHJxY3Od61JsM2XqxUJBuRiKcE2R/4qEmx034qaBJFJZAStQjUjJYgYlBJENSMkSKhmpARRzQgJNjqLuCZBZBIpQWQSIUGNTCIliPckQoKNzn2eRTBSv7E3RU4IWvTqpASNnCCF0AufvpHOE7TW99LdS4eRIWnKMXT9RvPejxsakw+/nY/f2Hn3ncl7/s7OT/eBIk85P9zbRF59MpFxx4Z+zoZ3amxq9lsGXof+geQN82Xh7ok1phgyKp6K79v6B+P/tdvqx7aePMny7jvy/amdNuMD1dBv78N39j5+a/bTuy1E5U+975Tc9BYDOaUSS9OLoTNKus2ep1aDF5rMWQngTJtF1AQUREoKpdGJXRNQ2uwHX4biECkZKIiUFIpvcxCEIw9QlL0sTGro73dNDQnBRufB1yPY6MaKswiSHttnKSHYZrlUkWBsM2PWJNhmeq1H0Cvk4mmCbhyQCeeZxDf6iYtZBI3q93jv/kxikNucoFKRoG5zgkpNgqhmpATbnKAyi6DloX3di+xzgo0u5K1JEDEoJGiRi4UEHSpqKUH06oQEG12GWpEgxgfFBDFGLSTY6CLKmgQRgzKCodFFlPMI+mG6rY2cEEQ1IyTY6BLAigQbXcBWkyAyiZCgRiaREjQgKCSIXCwk2Oh3KmYR1OPyK63P35MEi/FBKUHkYiHBRj+XUZMgcrGUIHKxkCDmUYsJopoREgyIQSlBVDNCgo1+pL4mQQOCQoKoZqYJmmH1uXbnb5qiQgwKCRJG+aUEkYuFBBn1oJQg+iRCgpjLLyaIedSy1RDRYM6ClCCeg0KCje7dUpEg5vKfEeygkMpvIOl1v9+CNzrRyc9Ij6Y3FG1qJ/8poMs6+c3vJnT8fJ0v5uZe3HSi03IFWvTFHMwpLVuiRUW2qMgWF9niIlu6yJYuul6myJYpatcXK94mtL7IDFNavkTLUZGWm/2Mofzn67qBpf4+5ozO/OcS5e/ii3ZYqQIdU6AT5usQz2bANP+ZyVxgJ3/fTujMv6ZsCuyYEjv5nGb7uI6eE518vp3QKbDj/Hyd/DvoCZ0CO6HATv7N2sn1yejk8/rlaxrdbB2tqEBnfj2kyczXYVWgM/95oDUX6IT5OkYX6BTYsQXtsQWx4wquj5sZBx/d0b93u9Xd/Xr50mnsf3zbPLyutpvj4et/z/0v97vVer16un3ebR+Wj2+75e16+7D/baGO//zkoG66oD9Uwd0hRX1DMRzSaXeoFXe/ms5qZ/l/",
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "rZLdCoMgGIbvxeMOzH93K2OElYUgFlaDEd37LGyLGu2kE/GTh5dHfUdQ6nyoM+OqpgO3+whsU6jeNC5M45SA3BtrTZ1tjwGclxQvfNcqN49dr3wPbikkqUiAduWy5zxkVMbqeaJTcuC5YJEWkHxYjn6gFNGIUgq/sYRPjwSk5AobgflqQ+W5DcEyooSJgw29xEaQ1UaKcxsG17dhiB1s2BU2EqFIS0z/2AgYUQ53PzWF8am8UbnVsWLV4IpN4/pXq3fla31T6HLweq7hpoFhvYc7IBxiQ/Qb",
       "brillig_names": [
-        "check_balance"
+        "sync_notes"
       ]
     },
     {
@@ -1735,13 +1765,13 @@
             "error_kind": "string",
             "string": "attempt to multiply with overflow"
           },
-          "14514982005979867414": {
+          "14225679739041873922": {
             "error_kind": "string",
-            "string": "attempt to bit-shift with overflow"
+            "string": "Index out of bounds"
           },
-          "16761564377371454734": {
+          "14514982005979867414": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "attempt to bit-shift with overflow"
           },
           "17288131482828810359": {
             "error_kind": "string",
@@ -1753,8 +1783,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -1770,16 +1800,16 @@
       "verification_key": "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"
     },
     {
-      "name": "balance_of_public",
+      "name": "_increase_public_balance",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "view"
+        "internal"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "owner",
+            "name": "to",
             "type": {
               "kind": "struct",
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
@@ -1793,16 +1823,18 @@
               ]
             },
             "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "kind": "integer",
+              "sign": "unsigned",
+              "width": 128
+            },
+            "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "integer",
-            "sign": "unsigned",
-            "width": 128
-          },
-          "visibility": "public"
-        },
+        "return_type": null,
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -1812,13 +1844,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "16761564377371454734": {
+          "10502589790419500451": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Function _increase_public_balance can only be called internally"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -1826,46 +1854,27 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bbuM4DIbfJde9EKnzvMpgUfSQKQIESZG2CyyKvvs6mdhOKyEei0KRjP6bok5Ek/oii5REye+Lx+X929PtavNr+7L48fN9sd4+3L2utpvu6v3jZnG/W63Xq6fb048Xav+HFB8EXp7vNvvrl9e73eviB7FlulksN4+H/43ubvJrtV7ur8LHTVLek4rH4r4rP5T2JlM4suNj4cjhU+F/bjqL/J9YZD9ZtJcjLpQr1Me2TE6rnBwr545irE6gWJshSMrpXgfRyY/jYq506O9MMQxlNevf5pjLMidelDnmsuiYy6JjL4uODRdljuPLMsdflDmevtscO96ZP5mT8WfR2N6fxTjemYPLlNbDnQ2rsWzO9zFF01vBxOcLW+7va9mfFj3wc+An4RcU+In4WfCT8ItofzJ+aH8SfqzQ/mT8DPiJ+AXwk/AjDX4ifh78JPyYwU/ED+O3SX5O9fwcfeWnEb/I+CF+lvGL4DfFbyjrPhfd83N4fmX8DPiJ+OH5FfHzaH8yfmh/In4B7U/GD/MvIn4R418ZP8y/SPhphfVzGT/Mv4j4EcZvMn6Yf5HxQ/ycQmEsCmWgINJNoWiErxkoiAlSKAaBZgYKvHcGClxyCuX7c+SvAQpccgrFwSVnoGCaKIWCvRM5KHDJKRTscshBQZifQsF+hBwU9CkJFIOdAxko3CYU1iOUk73uRyi6zTDfU38YAnutiwvvCZo2xwRzCJIb6+cCJQTbHEBUJGjbdIIVCTaa61qToAHBKYLe9zcmHxNf3Gi+a0WCvs3F1ZoE4YuFBEObM381CSKakRKEJxESjAYEhQTRBmUErUI0IyWIaEZIkBDNSAkimpEShCcREmw06bgmQXgSIcFG05lrEmwzKWIWwUj9weUUOSH4/WdF/3UEK6wXUwi9htMV6TxBa31fult0GBmSphxD15/s7v14oDH5w7nu1uprNv6ayTt3xcb/QS5n9FPGD882kVefVGTMsaHP2fBOjVXNvqvB69B3SN4wny/c9VijiyGj4mnxQ139t9fVj3U96cny5jvy/a2dNmOHauhgfeCrtv6a2btGd2trNVihyXxxl67R6ZMJKGgpKRQ2gJJCaXPm5zwUjZaSgYKWkkIxbU77ceQBirITw101jI27qoaEYJvTfhUJ2jYjoFkESY/1s5QQbDNcqkiw0dTUmgTbdK8VCTaamjqPoBsnL0LiSRpNyZpF0Kj+PPTu36QNxjY3e9Uj6FWbi5g1CSKaERJs9FjHWQQtD/WzViUE20zJqkiw1b3UFQnCFwsJakTUUoIY1QkJGkQzQoKYHxQTxBy1kGCjx/rVJIg2KCTY6IGB8wj6ITXVRk4IIpoREmz0hU0VCTb6yqGaBOFJZARDo68dqkkQ84NSgvDFQoKE+cFJgnrcqqT113WS0Oim15oE4YuFBDV8sZQgfLGUIHyxkCDyqMUEEc0ICVq0QSlBRDNCgg7RjJQgohkpQUQz0wTNsFNbu68rTaHRtzBVJBgwyy8lCF8sJBgRD0oJYkwiIxiRyy8liFx+4W6ISAYEhQTRDwoJNnp2S0WCyOX/QrCDQoqzIzWv+/MWvNGJTD4jPZpeUbSpHqsKZEyBTJgvk8/NPX/oRPeRL5HK52BOSrkSqVCkKxTpikW6YokuUlQkVfJ7ERXpoqJ65Xe8TUqZIqlQIqW5SMrP7mPIZLlH1R8mGDkjM79fovxTfF6PL7AtPyM2IRPnywQ9n0GY32dSnK+H88/thMz835SpQA8V6Mk/r9H27Tp6TmXsfBldoCf/0t3zMvk16AmZAj22QE9+Ze3k98nI5P36+d/U+fkyvkBPUAUydr5MLHgW4vz+QCtdIBPny5ApkCnQwwX14fltR2sqkJnZDj66q3/vdqu7+/XypZPYf/m2eXhdbTfHy9f/nvtv7ner9Xr1dPu82z4sH992y9v19mH/3UId//zsGvwNR32I4LrL/aHZ9PtyXxmOpvvWdVo7zf8D",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "balance_of_public"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "aztec::macros::functions::utility"
-      ],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLdCoMgGIbvxeMOzN/P3coYw8qGIBZWgxHd+2zYFmu0k07ETx5eHvUdUWWK4Xa1vm46dDqPyDWl7m3j4zROGSqCdc7erutjhOclpy++a7Wfx67XoUenHLMcMmR89dpLGTNq60ycCEzZhpcgEg2YvVkpfqCc8IRyjj+xnEyXDOXsCBugcrHhat+GUZVQJmBjww+xAbbYKNi3EXh5G0HExkYcYaMISbSi/I8N4IRK/PVTUxzvOlhdOJMqVg++XDWuf7Tmq3xtaEpTDcHMNVw1MK7neAdCY2yMfgI=",
-      "brillig_names": [
-        "sync_notes"
+        "_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"
           }
@@ -1876,15 +1885,6 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
           "3219842053230618354": {
             "error_kind": "string",
             "string": "Function check_balance can only be called statically"
@@ -1893,32 +1893,20 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
           "15238796416211288225": {
             "error_kind": "string",
             "string": "Balance too low"
           },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgIEAScCAwQAHxgAAwACgEouCIBKAAElAAAARSUAAAB3KAIAAQSASycCAgQAOw0AAQACKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgAAACgAgEcBAAEoAIBIBAABKACASQQAAiYlAAAHkykCAAIA5/BF/wo4AQIDJwIEBAAnAgYEAwA4BAYFLQgBAgAQAQUBJwMCBAEAKAICBS0OBAUAKAUCBS0OBAUnAgUEAwA4AgUEJwIEAAEnAgUAJSQCAAMAAADaIwAAAsAtCAEDJwIGBAMAEAEGAScDAwQBACgDAgYfJIBIgEkABi0NAwYAKAYCBi0OBgMtCAEGAAABAgEtDgMGLQgBAwAAAQIBLgqARQADJwIIBAktCAAJLQwGCi0MAwsAEAAIACUAAAe8LQQAAC0MCgcBKAAHgEgACS0NCQgnAgkECi0IAAotDAYLLQwDDAAQAAkAJQAAB7wtBAAALQwLBycCBgQJLQgACS0MBwoAEAAGACUAAAg1LQQAAC0MCgMtCAEGAAABAgEuCoBEAAYtCAEHAAABAgEuCoBGAActCAEJAAABAgEnAgoANC0OCgkeAgAKAR4CAAsACjgKCwwkAgAMAAAB4CUAAAhaJwIOBA8tCAAPLQwGEC0MBxEtDAkSLQwEEy0MBRQtDAgVABAADgAlAAAIbC0EAAAtDBAKLQwRCy0MEgwtDBMNLwwADQAOHAwODwYcDA8NABwMDQ4GADgOAw0OOA4NDyQCAA8AAAJLJQAAC5snAhEEEi0IABItDAYTLQwHFC0MCRUtDAQWLQwFFy0MCBgAEAARACUAAAhsLQQAAC0MEwMtDBQOLQwVDy0MFhAcDA0GADAMAAYAEC0NAgYAKAYCBi0OBgIAKAICCC0NCAcnAgkEAgA4CAkGOw0ABgAHIwAAAsApAgADAPAkOdsKOAEDBiQCAAYAAALbIwAABD4tCAEDJwIGBAIAEAEGAScDAwQBACgDAgYfJIBIgEgABi0NAwYAKAYCBi0OBgMtCAEGAAABAgEtDgMGLQgBAwAAAQIBLgqARQADJwIIBAktCAAJLQwGCi0MAwsAEAAIACUAAAutLQQAAC0MCgcnAgYECC0IAAgtDAcJABAABgAlAAAINS0EAAAtDAkDLQgBBgAAAQIBLgqARAAGLQgBBwAAAQIBLgqARgAHLQgBCAAAAQIBJwIJADEtDgkIHgIACQkKOAkECiQCAAoAAAOtJQAADCYeAgAJAScCDgQPLQgADy0MBhAtDAcRLQwIEi0MBBMtDAUULQwJFQAQAA4AJQAACGwtBAAALQwQCi0MEQstDBIMLQwTDS8MAA0ABhwMBggGHAwIBwAcDAcGBgw4BgMHCygAB4BEAAMkAgADAAAEICUAAAw4ACgCAgctDQcGJwIIBAIAOAcIAzsNAAMABiMAAAQ+KQIAAgD/eUnyCjgBAgMkAgADAAAEWSMAAAXGLQgBAicCAwQCABABAwEnAwIEAQAoAgIDHySASIBIAAMtDQIDACgDAgMtDgMCLQgBAwAAAQIBLQ4CAy0IAQIAAAECAS4KgEUAAicCBwQILQgACC0MAwktDAIKABAABwAlAAALrS0EAAAtDAkGASgABoBIAAMtDQMCLQgBAwAAAQIBLgqARAADLQgBBgAAAQIBLgqARgAGLQgBBwAAAQIBJwIIABItDggHHgIACAkKOAgECSQCAAkAAAUYJQAADEonAgwEDS0IAA0tDAMOLQwGDy0MBxAtDAQRLQwFEi0MAhMAEAAMACUAAAhsLQQAAC0MDggtDA8JLQwQCi0MEQsvDAALAAIcDAIEBhwMBAMAJwIEBAEnAgYEAwA4BAYFLQgBAgAQAQUBJwMCBAEAKAICBS0OBAUAKAUCBS0OBAUnAgUEAwA4AgUELQwEBS0OAwUAKAICBS0NBQQnAgYEAgA4BQYDOw0AAwAEIwAABcYnAgICVScCAwJuJwIEAmsnAgUCbycCBgJ3JwIHAiAnAggCcycCCQJlJwIKAmwnAgsCYycCDAJ0JwINAnInAg4CeycCDwJ9LQgBECcCEQQcABABEQEnAxAEAQAoEAIRLQwREi0OAhIAKBICEi0OAxIAKBICEi0OBBIAKBICEi0OAxIAKBICEi0OBRIAKBICEi0OBhIAKBICEi0OAxIAKBICEi0OBxIAKBICEi0OCBIAKBICEi0OCRIAKBICEi0OChIAKBICEi0OCRIAKBICEi0OCxIAKBICEi0ODBIAKBICEi0OBRIAKBICEi0ODRIAKBICEi0OBxIAKBICEi0ODhIAKBICEi0OCBIAKBICEi0OCRIAKBICEi0OChIAKBICEi0OCRIAKBICEi0OCxIAKBICEi0ODBIAKBICEi0OBRIAKBICEi0ODRIAKBICEi0ODxILIIBEgEcAAiQCAAIAAAeSJwIDBB4tCAEEJwIFBB4AEAEFAS0MBAUqAwAFBSdGSLL1QRe9ACgFAgUAKBACBicCBwQbLgQABoADLgQABYAELgQAB4AFJQAADFwnAgYEGwA4BQYFLgqASAAFACgFAgUtDgEFACgFAgU8DQQDJigAgAQEeAANAAAAgASAAyQAgAMAAAe7KgEAAQX3ofOvpa3UyjwBAQImJQAAB5MtDQEDLQ0CBCcCBgQCDDgEBgckAgAHAAAH4CUAAAyiACgDAgYAOAYEBy0NBwUtCAEGJwIHBAIAEAEHAScDBgQBACgGAgctDAcILQ4FCAEoAASASAAFDjgEBQckAgAHAAAIKCUAAAubLQ4DAS0OBQItDAYBJiUAAAeTASgAAYBIAAMtDQMCHAwCAwYcDAMBABwMAQIGLQwCASYqAQABBZHAscTvmT2jPAEBAiYlAAAHky0IAQgnAgkEAwAQAQkBJwMIBAEAKAgCCS0MCQotDgQKACgKAgotDgYKLQgBBCcCBgQEABABBgEnAwQEAQAoBAIGLQwGCS4KgEYACQAoCQIJLgqARgAJACgJAgkuCoBGAAktDQQGACgGAgYtDgYEKwIABgAAAAAAAAAAAgAAAAAAAAAALQgBCScCCgQFABABCgEnAwkEAQAoCQIKLQwKCy4KgEYACwAoCwILLgqARgALACgLAgsuCoBGAAsAKAsCCy0OBgstDQQGACgGAgYtDgYELQgBBgAAAQIBLQ4EBi0NCQQAKAQCBC0OBAktCAEEAAABAgEtDgkELQgBCQAAAQIBLgqARQAJLQgBCgAAAQIBLgqARAAKLgiARQAHIwAACZINKAAHgEkABSQCAAUAAAozIwAACactDQoFCygABYBEAAckAgAHAAAJxCcCCAQAPAkBCCcCBQQLLQgACy0MBgwtDAQNLQwJDi0MCg8AEAAFACUAAAy0LQQAAC0NBgUtDQQHLQ0JCC0OBQYtDgcELQ4ICS4KgEcACgEoAAeASAAFLQ0FBAsoAASARgAFCygABYBEAAYkAgAGAAAKMiUAAA4MJiQCAAUAAApAIwAAC4onAgsEAgw4BwsMJAIADAAAClclAAAMogAoCAILADgLBwwtDQwFLQ0JCy0NCgwLKAAMgEQADSQCAA0AAAqGJwIOBAA8CQEOCygAC4BDAAwkAgAMAAALFyMAAAqbLQ0GCy0NBAwtDQkNLQ0KDicCEAQDDDgNEBEkAgARAAAKwiUAAAyiLgQAC4ADKACABAQABCUAAA4eLgiABQAPACgPAhAAOBANES0OBREBKAANgEgABQ44DQULJAIACwAACwIlAAALmy0ODwYtDgwELQ4FCS0ODgojAAALiicCCwQMLQgADC0MBg0tDAQOLQwJDy0MChAAEAALACUAAAy0LQQAAC0NBgstDQQMLQ0KDS4EAAuAAygAgAQEAAQlAAAOHi4IgAUADgAoDgIPASgAD4BFABAtDgUQLQ4OBi0ODAQuCoBIAAktDg0KIwAAC4oBKAAHgEgABS0MBQcjAAAJkioBAAEFRafKcRlB5BU8AQECJiUAAAeTLQ0BAy0NAgQnAgYEAQw4BAYHJAIABwAAC9ElAAAMogAoAwIGADgGBActDQcFLQgBBicCBwQCABABBwEnAwYEAQAoBgIHLQwHCC0OBQgBKAAEgEgABQ44BAUHJAIABwAADBklAAALmy0OAwEtDgUCLQwGASYqAQABBSyvLUm3rObyPAEBAiYqAQABBdN7FJoYxQChPAEBAiYqAQABBVQ1YMByXTNuPAEBAiYBAIADgAWABy4AgAOACC4AgASACQsAgAiAB4AKJACACgAADKEuAYAIgAYuAoAGgAkBAIAIAAKACAEAgAkAAoAJIwAADHAmKgEAAQXonQn+oREtDjwBAQImJQAAB5MuCIBFAAUjAAAMxA0oAAWAQwAGJAIABgAADTQjAAAM2S0NAQUtDQIGLQ0DBy0NBAgnAgkEBC0IAQonAgsEBQAQAQsBJwMKBAEAKAYCCycCDAQEACgKAg0/DwALAA0tDQoGACgGAgYtDgYKLQ4FAS0OCgItDgcDLQ4IBCYtDQMGDDgFBgcBKAAFgEgABiQCAAcAAA1SIwAADgMtDQEHLQ0CCC0NAwktDQQKJwIMBAQMOAUMDSQCAA0AAA15JQAADKIAKAgCDAA4DAUNLQ0NCycCDQQDDDgFDQ4kAgAOAAANniUAAAyiACgHAg0AOA0FDi0NDgwAOAsMDScCDAQEDDgFDA4kAgAOAAANyCUAAAyiLgQACIADKACABAQABSUAAA4eLgiABQALACgLAgwAOAwFDi0ODQ4tDgcBLQ4LAi0OCQMtDgoEIwAADgMtDAYFIwAADMQqAQABBQLcbieAdhKdPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAA45IwAADkQuAIADgAUjAAAOqy4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAA6XLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAA5mKAGABQQAAQMAgAYAAoAGIwAADqsm",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcGLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAmkeAgACCScCAwABCjgCAwQkAgAEAAAAiiUAAAKSHgIAAgEnAgQAAC0IAQUnAgYEBAAQAQYBJwMFBAEAKAUCBi0MBgctDgQHACgHAgctDgQHACgHAgctDgQHLQ0FBgAoBgIGLQ4GBSsCAAYAAAAAAAAAAAIAAAAAAAAAAC0IAQcnAggEBQAQAQgBJwMHBAEAKAcCCC0MCAktDgQJACgJAgktDgQJACgJAgktDgQJACgJAgktDgYJLQ0FBgAoBgIGLQ4GBS0NBwYAKAYCBi0OBgctCAEGAAABAgEtDgUGLQgBBQAAAQIBLQ4HBS0IAQcAAAECAS4KgEUABy0IAQgAAAECAS4KgEQACCcCCQQKLQgACi0MBgstDAUMLQwHDS0MCA4tDAMPABAACQAlAAACpC0EAAAnAgMECS0IAAktDAYKLQwFCy0MBwwtDAgNLQwCDgAQAAMAJQAAAqQtBAAALQ0IAgsoAAKARAADJAIAAwAAAegnAgkEADwJAQknAgIECS0IAAktDAYKLQwFCy0MBwwtDAgNABAAAgAlAAADuC0EAAAtDQUCASgAAoBGAAUtDQUDCjgDBAILKAACgEQABCQCAAQAAAI5JQAABMsvDAADAAIcDAIEBhwMBAMAHAwDAgYMOAIBAwsoAAOARAABJAIAAQAAAmglAAAE3SYoAIAEBHgADQAAAIAEgAMkAIADAAACkSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFLK8tSbes5vI8AQECJiUAAAJpLQ0DBi0NBAcLKAAHgEQACCQCAAgAAALKJwIJBAA8CQEJCygABoBDAAckAgAHAAADRCMAAALfLQ0BBi0NAgctDQMILQ0ECS4EAAaAAygAgAQEAAQlAAAE7y4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAMvJQAABX0tDgoBLQ4HAi0OBQMtDgkEIwAAA7cnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADuC0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABO8uCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAO3JiUAAAJpLgiARQAFIwAAA8gNKAAFgEMABiQCAAYAAAQ4IwAAA90tDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEViMAAATCLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAE7y4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAATCLQwGBSMAAAPIKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXTexSaGMUAoTwBAQImLgGAA4AGCwCABgACgAckAIAHAAAFCiMAAAUVLgCAA4AFIwAABXwuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFaC4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFNygBgAUEAAEDAIAGAAKABiMAAAV8JioBAAEFRafKcRlB5BU8AQECJg==",
+      "debug_symbols": "7Z3bbuM4DIbfJde50JnUvMpiMUjbdBAgSIu0XWBR9N3HzkS2a1PWmArmAPOmqFv+EfVFEinZlt43D/u7t29fD6fHp5fNl3/eN8en+93r4enUXL1/bDd358PxePj2dfjnjWp/aK0ugpfn3am9fnndnV83X7TxRm83+9PD5Xdnmw95PBz3zZXyH9uJPWgVr+bQ2HfWoAjjaIK5GkeDn4z/3TYe+Z/xyH/yqNUZxdQxy7OWqUNShyEkGaLrVF4TBB1adzV26Mw8bvSQcKNHGON2dDXQ9e4EP++OVsEmY60HbSU4ytqnTzaqd92aQLWr6HxqVzH2n2wwEtYWVKJie4KGgmKMTh9sjLXzxt7B1dY7HJpe+KHwq+HnjfCr4gfCr4ZfkPZXx0/aXxU/kPZXxy8Ivxp+qIRfFT8v/Kr4ReFXwy864VfFT+ZvRX6YVjQ8mhG/pg7Cr4qf5M9V/LQWfgV+obMNn01bflb6bx0/mX9U8XPSf+v4Sfur4uel/dXxk/ZXxS/I+ksdPyf8qvjJ+ksVP5D753X8ZP2lih/K/K2On6y/VPGLkj8TUOSm0ASKVZLpElCcQJlCkZxgCkVLoklAkeg9hWIkJBNQZJ1qCsVKSCagSEgmoMgy0RSKvDtBQZGQPIUibzlQUCTNn0KR9xEoKDKmTKGs9M5DMxFOXlyKHkFZ55gyD2Wl9wgKUNY5IZyHEtc5ISxAcQJlCkUG2gkUt9KH4QtQ1pm8zUPR0lIIKBKSp1BWuppfgLLOG+wFKOtco52HYmWWTECRkDyFstI3UQpQZKCdQvEySyagSEshoKwzJINLtgY837glGNYZv5cQ1AHTdoAa1PgNaQfrjGu3JCi9uJIgOiFYSXCd662LCEKEDoaexOIokaSW4Dqnjbcj6JXE4lqC65xm3JKgZDOVBFf6KsYtCUo2U0nQSBusJSjZTCVBK9lMkWC0Xf2imxKUWFxJ8BbvYGjEZGyGJ3aQBL2PyfmApndeK6QYhrR3IUC/96gG+8N5/Iudv8XOT7/N+VtsG/T7nC+PGtGUnO/6ttbtuTGDIgh3fLc2BUEVzvcBi6nDgjOF02maEQs6r7VTcWje1hX8L68r9HU1quB+0F2ADINhzzp38f4ndlf/k73/q9mXn2WOCobeX0R+uSgoyxCVN64lREiLVBdPm+EkjkJkyHyNBRE9xmjv+q9zvEgdMguEsyLIrOjMizLnlhVE9KDfDPXdOK7GIMDS7rn+mK/hIJdEkSHKpDIFETBEmU0vvevoedATETBEmThbEEWGKBMo5kWZ8bkgYpWUqVPsktugx694QaY/zYow8xD6vCjTnwoizxExQGBmtaMg4tDL7Ods+0mI9eP+hJlHxwoizxFFhshbjggYosABETjIgVMScJADBzlykGf2orOhm2dYHA8smLmtOSuKmb24CiLPEGXSnIIoMETGcUS4PHzGzJ75BVFgiBynpEDWqZm4dan1+CmrSEen2K0sRRgvvES63c1LYKlEK/qOaUHDSHi1yoTAksqxVJGjMqyyDKssyyrLsspyrLI86/vyvLJY9co8u1hSAUcFmqVi9RQ6a54bYBoNyT2atDoQHaFZPCrpzIHWs+Vo7RgaXK4xhqEJyxlYzdAwynE0a0zt4NNNg6TxyzWeUQ7dzwf1oTSM9hb8cg195mdBszx2arQMDS7XREY5jFzAMHIBozxDs7AdfDRX/+3Oh93dcX89cv/x7XQ/OIH/9f/n/egw/ufz0/3+4e28b4/l70/kb5u6cXFrQF3GwOayGTe22sAFW/tf0M1/bVNqU/J3",
       "brillig_names": [
-        "public_dispatch"
+        "check_balance"
       ]
     }
   ],
@@ -2008,7 +1996,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -2021,35 +2009,23 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
-                  },
-                  {
-                    "name": "amount",
-                    "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 128
-                    }
-                  },
-                  {
-                    "name": "secret",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "message_leaf_index",
-                    "type": {
-                      "kind": "field"
-                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::claim_parameters"
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 128
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::claim_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -2096,36 +2072,21 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "fee_limit",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 128
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 128
+                "path": "FeeJuice::check_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::check_balance_abi"
         },
         {
           "fields": [
@@ -2134,67 +2095,90 @@
               "type": {
                 "fields": [
                   {
-                    "name": "fee_limit",
+                    "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
                     }
+                  },
+                  {
+                    "name": "secret",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "message_leaf_index",
+                    "type": {
+                      "kind": "field"
+                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::check_balance_parameters"
+                "path": "FeeJuice::claim_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::check_balance_abi"
+          "path": "FeeJuice::claim_abi"
         }
       ]
     }
   },
   "file_map": {
-    "121": {
-      "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 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        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\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"
-    },
-    "128": {
+    "105": {
       "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_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, 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 transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\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 utility 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    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\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_body(modified_body);\n\n    f.set_return_public(true);\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\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "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_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, 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 transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\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 utility 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    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\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_body(modified_body);\n\n    f.set_return_public(true);\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::messages::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::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
-    "131": {
+    "108": {
       "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"
+      "source": "use poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault};\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"
     },
-    "133": {
+    "128": {
       "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"
     },
-    "151": {
+    "146": {
       "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"
     },
-    "152": {
+    "147": {
       "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"
     },
-    "153": {
+    "148": {
       "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"
     },
-    "155": {
+    "150": {
       "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"
     },
-    "164": {
+    "159": {
       "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::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"
     },
-    "169": {
+    "164": {
       "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"
     },
-    "178": {
+    "173": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UtilityContext};\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> PublicMutable<T, &mut PublicContext> {\n    // docs:start:public_mutable_struct_read\n    pub fn read<let T_PACKED_LEN: u32>(self) -> T\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\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<let T_PACKED_LEN: u32>(self, value: T)\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T> PublicMutable<T, UtilityContext> {\n    pub unconstrained fn read<let T_PACKED_LEN: u32>(self) -> T\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
@@ -2202,81 +2186,85 @@
       "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"
     },
-    "24": {
+    "20": {
       "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"
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub(crate) 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(crate) 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(crate) 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(crate) 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"
     },
-    "268": {
+    "271": {
       "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"
     },
-    "286": {
+    "289": {
       "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"
     },
-    "296": {
+    "299": {
       "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"
     },
-    "303": {
+    "306": {
       "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"
     },
-    "323": {
+    "326": {
       "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"
     },
-    "341": {
+    "344": {
       "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"
     },
-    "342": {
+    "345": {
       "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"
     },
-    "361": {
+    "364": {
       "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"
     },
-    "367": {
+    "370": {
       "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"
     },
-    "43": {
+    "39": {
       "path": "std/ops/arith.nr",
       "source": "// docs:start:add-trait\npub trait Add {\n    fn add(self, other: Self) -> Self;\n}\n// docs:end:add-trait\n\nimpl Add for Field {\n    fn add(self, other: Field) -> Field {\n        self + other\n    }\n}\n\nimpl Add for u128 {\n    fn add(self, other: u128) -> u128 {\n        self + other\n    }\n}\nimpl Add for u64 {\n    fn add(self, other: u64) -> u64 {\n        self + other\n    }\n}\nimpl Add for u32 {\n    fn add(self, other: u32) -> u32 {\n        self + other\n    }\n}\nimpl Add for u16 {\n    fn add(self, other: u16) -> u16 {\n        self + other\n    }\n}\nimpl Add for u8 {\n    fn add(self, other: u8) -> u8 {\n        self + other\n    }\n}\nimpl Add for u1 {\n    fn add(self, other: u1) -> u1 {\n        self + other\n    }\n}\n\nimpl Add for i8 {\n    fn add(self, other: i8) -> i8 {\n        self + other\n    }\n}\nimpl Add for i16 {\n    fn add(self, other: i16) -> i16 {\n        self + other\n    }\n}\nimpl Add for i32 {\n    fn add(self, other: i32) -> i32 {\n        self + other\n    }\n}\nimpl Add for i64 {\n    fn add(self, other: i64) -> i64 {\n        self + other\n    }\n}\n\n// docs:start:sub-trait\npub trait Sub {\n    fn sub(self, other: Self) -> Self;\n}\n// docs:end:sub-trait\n\nimpl Sub for Field {\n    fn sub(self, other: Field) -> Field {\n        self - other\n    }\n}\n\nimpl Sub for u128 {\n    fn sub(self, other: u128) -> u128 {\n        self - other\n    }\n}\nimpl Sub for u64 {\n    fn sub(self, other: u64) -> u64 {\n        self - other\n    }\n}\nimpl Sub for u32 {\n    fn sub(self, other: u32) -> u32 {\n        self - other\n    }\n}\nimpl Sub for u16 {\n    fn sub(self, other: u16) -> u16 {\n        self - other\n    }\n}\nimpl Sub for u8 {\n    fn sub(self, other: u8) -> u8 {\n        self - other\n    }\n}\nimpl Sub for u1 {\n    fn sub(self, other: u1) -> u1 {\n        self - other\n    }\n}\n\nimpl Sub for i8 {\n    fn sub(self, other: i8) -> i8 {\n        self - other\n    }\n}\nimpl Sub for i16 {\n    fn sub(self, other: i16) -> i16 {\n        self - other\n    }\n}\nimpl Sub for i32 {\n    fn sub(self, other: i32) -> i32 {\n        self - other\n    }\n}\nimpl Sub for i64 {\n    fn sub(self, other: i64) -> i64 {\n        self - other\n    }\n}\n\n// docs:start:mul-trait\npub trait Mul {\n    fn mul(self, other: Self) -> Self;\n}\n// docs:end:mul-trait\n\nimpl Mul for Field {\n    fn mul(self, other: Field) -> Field {\n        self * other\n    }\n}\n\nimpl Mul for u128 {\n    fn mul(self, other: u128) -> u128 {\n        self * other\n    }\n}\nimpl Mul for u64 {\n    fn mul(self, other: u64) -> u64 {\n        self * other\n    }\n}\nimpl Mul for u32 {\n    fn mul(self, other: u32) -> u32 {\n        self * other\n    }\n}\nimpl Mul for u16 {\n    fn mul(self, other: u16) -> u16 {\n        self * other\n    }\n}\nimpl Mul for u8 {\n    fn mul(self, other: u8) -> u8 {\n        self * other\n    }\n}\nimpl Mul for u1 {\n    fn mul(self, other: u1) -> u1 {\n        self * other\n    }\n}\n\nimpl Mul for i8 {\n    fn mul(self, other: i8) -> i8 {\n        self * other\n    }\n}\nimpl Mul for i16 {\n    fn mul(self, other: i16) -> i16 {\n        self * other\n    }\n}\nimpl Mul for i32 {\n    fn mul(self, other: i32) -> i32 {\n        self * other\n    }\n}\nimpl Mul for i64 {\n    fn mul(self, other: i64) -> i64 {\n        self * other\n    }\n}\n\n// docs:start:div-trait\npub trait Div {\n    fn div(self, other: Self) -> Self;\n}\n// docs:end:div-trait\n\nimpl Div for Field {\n    fn div(self, other: Field) -> Field {\n        self / other\n    }\n}\n\nimpl Div for u128 {\n    fn div(self, other: u128) -> u128 {\n        self / other\n    }\n}\nimpl Div for u64 {\n    fn div(self, other: u64) -> u64 {\n        self / other\n    }\n}\nimpl Div for u32 {\n    fn div(self, other: u32) -> u32 {\n        self / other\n    }\n}\nimpl Div for u16 {\n    fn div(self, other: u16) -> u16 {\n        self / other\n    }\n}\nimpl Div for u8 {\n    fn div(self, other: u8) -> u8 {\n        self / other\n    }\n}\nimpl Div for u1 {\n    fn div(self, other: u1) -> u1 {\n        self / other\n    }\n}\n\nimpl Div for i8 {\n    fn div(self, other: i8) -> i8 {\n        self / other\n    }\n}\nimpl Div for i16 {\n    fn div(self, other: i16) -> i16 {\n        self / other\n    }\n}\nimpl Div for i32 {\n    fn div(self, other: i32) -> i32 {\n        self / other\n    }\n}\nimpl Div for i64 {\n    fn div(self, other: i64) -> i64 {\n        self / other\n    }\n}\n\n// docs:start:rem-trait\npub trait Rem {\n    fn rem(self, other: Self) -> Self;\n}\n// docs:end:rem-trait\n\nimpl Rem for u128 {\n    fn rem(self, other: u128) -> u128 {\n        self % other\n    }\n}\nimpl Rem for u64 {\n    fn rem(self, other: u64) -> u64 {\n        self % other\n    }\n}\nimpl Rem for u32 {\n    fn rem(self, other: u32) -> u32 {\n        self % other\n    }\n}\nimpl Rem for u16 {\n    fn rem(self, other: u16) -> u16 {\n        self % other\n    }\n}\nimpl Rem for u8 {\n    fn rem(self, other: u8) -> u8 {\n        self % other\n    }\n}\nimpl Rem for u1 {\n    fn rem(self, other: u1) -> u1 {\n        self % other\n    }\n}\n\nimpl Rem for i8 {\n    fn rem(self, other: i8) -> i8 {\n        self % other\n    }\n}\nimpl Rem for i16 {\n    fn rem(self, other: i16) -> i16 {\n        self % other\n    }\n}\nimpl Rem for i32 {\n    fn rem(self, other: i32) -> i32 {\n        self % other\n    }\n}\nimpl Rem for i64 {\n    fn rem(self, other: i64) -> i64 {\n        self % other\n    }\n}\n\n// docs:start:neg-trait\npub trait Neg {\n    fn neg(self) -> Self;\n}\n// docs:end:neg-trait\n\n// docs:start:neg-trait-impls\nimpl Neg for Field {\n    fn neg(self) -> Field {\n        -self\n    }\n}\n\nimpl Neg for i8 {\n    fn neg(self) -> i8 {\n        -self\n    }\n}\nimpl Neg for i16 {\n    fn neg(self) -> i16 {\n        -self\n    }\n}\nimpl Neg for i32 {\n    fn neg(self) -> i32 {\n        -self\n    }\n}\nimpl Neg for i64 {\n    fn neg(self) -> i64 {\n        -self\n    }\n}\n// docs:end:neg-trait-impls\n"
     },
-    "47": {
+    "43": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "54": {
+    "50": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/fee_juice_contract/src/lib.nr",
       "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\nuse dep::aztec::protocol_types::traits::ToField;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: u128) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = (amount as Field).to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { keccak256::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     },
-    "55": {
+    "51": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/fee_juice_contract/src/main.nr",
       "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::{\n            address::{AztecAddress, EthAddress},\n            constants::FEE_JUICE_ADDRESS,\n            traits::ToField,\n        },\n        state_vars::{Map, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n    use std::ops::Add;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<u128, Context>, Context>,\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: u128, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = EthAddress::from_field(FEE_JUICE_ADDRESS.to_field());\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: u128) {\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: u128) {\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub u128 {\n        storage.balances.at(owner).read()\n    }\n}\n"
     },
-    "66": {
+    "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    gas_opts: GasOpts,\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            gas_opts: GasOpts::default(),\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n\n    pub fn set_as_teardown(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.set_public_teardown_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            false,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n"
     },
-    "73": {
+    "69": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "74": {
+    "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
       "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "76": {
+    "72": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "99": {
+    "76": {
       "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"
+    },
+    "98": {
+      "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 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        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\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"
     }
   }
 }