npm - @aztec/protocol-contracts - Versions diffs - 0.85.0 → 0.86.0-nightly.20250425 - Mend

@aztec/protocol-contracts 0.85.0 → 0.86.0-nightly.20250425

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/artifacts/AuthRegistry.json +258 -258
package/artifacts/ContractClassRegisterer.json +156 -152
package/artifacts/ContractInstanceDeployer.json +122 -122
package/artifacts/FeeJuice.json +83 -83
package/artifacts/MultiCallEntrypoint.json +6 -6
package/artifacts/Router.json +168 -168
package/dest/protocol_contract_data.js +7 -7
package/package.json +4 -6
package/src/protocol_contract_data.ts +7 -7

package/artifacts/AuthRegistry.json CHANGED Viewed

@@ -4,7 +4,7 @@
   "name": "AuthRegistry",
   "functions": [
     {
-      "name": "is_consumable",
+      "name": "is_reject_all",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
@@ -27,13 +27,6 @@
               ]
             },
             "visibility": "private"
-          },
-          {
-            "name": "message_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
           }
         ],
         "return_type": {
@@ -51,9 +44,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "5444967152290923376": {
+          "9474245853673257536": {
             "error_kind": "string",
-            "string": "Function is_consumable can only be called statically"
+            "string": "Function is_reject_all can only be called statically"
           },
           "14225679739041873922": {
             "error_kind": "string",
@@ -65,14 +58,14 @@
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEguCIBIAAEuCIBJAAIlAAAAUSUAAAB1LgQAAYBKKAIAAgSASicCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgEAASgAgEcEAAEmJQAABLweAgAECScCBQABCjgEBQYkAgAGAAAAliUAAATlJwIEAAItCAEFJwIGBAMAEAEGAScDBQQBACgFAgYtDAYHLQ4EBwAoBwIHLQ4BBycCAQAALQgBBCcCBgQEABABBgEnAwQEAQAoBAIGLQwGBy0OAQcAKAcCBy0OAQcAKAcCBy0OAQctDQQGACgGAgYtDgYEKwIABgAAAAAAAAAAAgAAAAAAAAAALQgBBycCCAQFABABCAEnAwcEAQAoBwIILQwICS0OAQkAKAkCCS0OAQkAKAkCCS0OAQkAKAkCCS0OBgktDQQIACgIAggtDggELQ0HCAAoCAIILQ4IBy0IAQgAAAECAS0OBAgtCAEEAAABAgEtDgcELQgBBwAAAQIBLgqARQAHLQgBCQAAAQIBLgqARAAJJwIKBAIuCIBFAAMjAAABugw4AwoLJAIACwAABGAjAAABzC0NCQULKAAFgEQACyQCAAsAAAHpJwIMBAA8CQEMJwIFBAstCAALLQwIDC0MBA0tDAcOLQwJDwAQAAUAJQAABPctBAAALQ0IBS0NBAstDQcMLQ4FCC0OCwQtDgwHLgqARgAJASgAC4BHAAUtDQUECjgEAQULKAAFgEQAByQCAAcAAAJUJQAABgotCAEFJwIHBAMAEAEHAScDBQQBACgFAgctDAcILQ4ECAAoCAIILQ4CCC0IAQInAgQEBAAQAQQBJwMCBAEAKAICBC0MBActDgEHACgHAgctDgEHACgHAgctDgEHLQ0CBAAoBAIELQ4EAi0IAQQnAgcEBQAQAQcBJwMEBAEAKAQCBy0MBwgtDgEIACgIAggtDgEIACgIAggtDgEIACgIAggtDgYILQ0CBgAoBgIGLQ4GAi0NBAYAKAYCBi0OBgQtCAEGAAABAgEtDgIGLQgBAgAAAQIBLQ4EAi0IAQQAAAECAS4KgEUABC0IAQcAAAECAS4KgEQABy4IgEUAAyMAAANUDDgDCggkAgAIAAAEBCMAAANmLQ0HAwsoAAOARAAFJAIABQAAA4MnAggEADwJAQgnAgMECC0IAAgtDAYJLQwCCi0MBAstDAcMABAAAwAlAAAE9y0EAAAtDQYDLQ0CBS0NBAgtDgMGLQ4FAi0OCAQuCoBGAAcBKAAFgEcAAy0NAwIKOAIBAwsoAAOARAABJAIAAQAAA+4lAAAGCi8MAAIAARwMAQMBHAwDAgAcDAIBASYkAgAIAAAEESMAAARPACgFAgkAOAkDCy0NCwgnAgkECy0IAAstDAYMLQwCDS0MBA4tDAcPLQwIEAAQAAkAJQAABhwtBAAAIwAABE8BKAADgEcACC0MCAMjAAADVCQCAAsAAARtIwAABKsAKAUCDAA4DAMNLQ0NCycCDAQNLQgADS0MCA4tDAQPLQwHEC0MCREtDAsSABAADAAlAAAGHC0EAAAjAAAEqwEoAAOARwALLQwLAyMAAAG6KACABAR4AA0AAACABIADJACAAwAABOQqAQABBfeh86+lrdTKPAEBAiYqAQABBUuQaMa9+INwPAEBAiYlAAAEvC4IgEUABSMAAAUHDSgABYBDAAYkAgAGAAAFdyMAAAUcLQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARwAGJAIABwAABZUjAAAGAS0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAAB0UuCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAGAS0MBgUjAAAFByoBAAEFAtxuJ4B2Ep08AQECJiUAAAS8LQ0DBi0NBAcLKAAHgEQACCQCAAgAAAZCJwIJBAA8CQEJCygABoBDAAckAgAHAAAG0SMAAAZXLQ0BBi0NAgctDQMILQ0ECQ0oAAiAQwAKJAIACgAABnwlAAAH0y4EAAaAAygAgAQEAAQlAAAHRS4IgAUACgAoCgILADgLCAwtDgUMASgACIBHAAUOOAgFBiQCAAYAAAa8JQAAB+UtDgoBLQ4HAi0OBQMtDgkEIwAAB0QnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAAE9y0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAAB0UuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARwADLQ4IBCMAAAdEJi4BgAOABgsAgAYAAoAHJACABwAAB2AjAAAHay4AgAOABSMAAAfSLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAAB74uAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAAB40oAYAFBAABAwCABgACgAYjAAAH0iYqAQABBcVrxFoOEAACPAEBAiYqAQABBUWnynEZQeQVPAEBAiY=",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACIh4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAksnAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGKwIABQAAAAAAAAAAAgAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OAggAKAgCCC0OAggAKAgCCC0OAggAKAgCCC0OBQgtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAACXS0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAl0tBAAALQ0HAQsoAAGARAADJAIAAwAAAbsnAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADiy0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIMJQAABJ4vDAADAAEcDAEDARwMAwIAHAwCAQEmKACABAR4AA0AAACABIADJACAAwAAAkoqAQABBfeh86+lrdTKPAEBAiYqAQABBYN7SGg+6XpAPAEBAiYlAAACIi0NAwYtDQQHCygAB4BEAAgkAgAIAAACgycCCQQAPAkBCQsoAAaAQwAHJAIABwAAAxcjAAACmC0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAAsIlAAAEsC4EAAaAAygAgAQEAAQlAAAEwi4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAMCJQAABVAtDgoBLQ4HAi0OBQMtDgkEIwAAA4onAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADiy0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABMIuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOKJiUAAAIiLgiARQAFIwAAA5sNKAAFgEMABiQCAAYAAAQLIwAAA7AtDQEFLQ0CBi0NAwctDQQILQ0GCQAoCQIJLQ4JBicCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEKSMAAASVLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAEwi4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAASVLQwGBSMAAAObKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAE3SMAAAToLgCAA4AFIwAABU8uAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFOy4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFCigBgAUEAAEDAIAGAAKABiMAAAVPJioBAAEFRafKcRlB5BU8AQECJg==",
+      "debug_symbols": "7Z3hTuMwDMffZZ/3IXYSJ75XOZ1OA8Zp0jTQgJNOiHe/dre2g3qEOdVJU/0FUfB/dn9N4sTp2tfF3frm5dfPze7+4Wnx7fvrYvtwu3rePOyao9e35eJmv9luN79+nv554dof4PggeHpc7drjp+fV/nnxDTACLRfr3d3hd5+bD7nfbNfNkQtvy5F98jEezZNP0FsTC8aMrjNmxHxq/GO5AAhfiCi4dxEddKzTodKfR6UuSbqQsz/KAreMj6roBILgqDMGAD+4IC9Zxy4gdNjbeozSheTQX0jmwRpzFqx9xC5moMHWSbYIDF0Y6LhgHZGPxtG7d7YtwoCGsBYhGcJKhBEMYS1Ca4W1CMlaYTVCa4W1CJMzhLUIgyGsRciGsBJh9oawFmE2hJUI2RZ4X0DI6WhMED8iRLCOXI3QKjW1CNE6cjVCa4W1CL21wmqE1gprEQar1FQjjIawEmG0Sk01wmAIaxFapaYWIdkCrxqhVWpqESabWn9EeMBiW0oSlmxTYBGLTWtFLDZJkLBwMCwSFkvmAhbvLEGLWKyeJWGxXSMZi7UWCYvt7shYZpqJmglbF4Y/iaPD4mc6tpSwzHRsKWCZ625JCctMl4olLDNdKhawRBtyRSw25EpYaKbTuRIWay0SlmQJWsQy08p/AUue6W0HJSzBsEhYbAUtYZnrbfElLDbkCliCsyFXxGIraAkLWGsRscw0Qaf+KSaYPnxB6zLrA8SZpvOLIAKR686QUh5BxJlmuUkheuvOE0CcabF1UohhpqXZyyCm1J9h4nF2DpZY6iHGma4qp4Vo2bkeIs10DTItxGAQ6yFaYqmHmGyKMwFEa4n1ELNNcSaAaFOcL0Bk19UTgXEMca5f3pgW4gRjIuTcucAQCxBj5G4xTxmHjwaXJIzU3R6cThb+kLANPjp/xcEDXHPwfMXBY3ngQF8Kvu/eAMm9cyGEk30XfMqx8Ez3RP3z3BJR/ty4iYOHESwinZq35+rdfz9XHM6V6PPwY+rGvZiHm/998P9ij9cbe7he7iTvX4LDTtSkzdHX1+nMywZKKjH/NLm4r/hCGFV8Sd7AKankHYuiijUquSYNQD0NyGMacsEBfP/cgObXsS95hV1SyY8bKKpIo5JvWSuqVOfFXqFKDlQqmUbsuyLEkEYqQJWKNaozr+QoqOSsUVRFjSqofIUz50X9bPd0ZOtUEVWqpFFR1KiSU6lUNOR6SEmVVQz5TP8aVicex/2LSaHKzqlUQaXKGtWZEaCkUtFAUKlUvryKvFeR9yry4Qz5EHpVTGNV1qhi1KjIqVSkUSVQqVijypq8nHPSqBhUKo2vZhovqVLoJnop0EgjZ6+hZMRx7Edug59r5HxX0NDlGrnNFjQKBsSXa+Stk8K6hM/kxoLqTG4sqZJGxSpfrPEFzqFOpvMGOm+QVTLUeTuTIUsy73SyePEo04jk7uK68YxRECnGpjZkhSfShCd355IoKUTyE9YKIDIpRKzxxDLyvsDAadyMQJ4al0QqT6WhWhKBou0BOo0oKUQeNaKsEMnlo5JI4ylqzkkxR2hKX5rrdPEs4a05/L3ab1Y32/Xxna33L7vbk1e4Pv95XH94m+vj/uF2ffeyX7fvdR1e6doGjJ6XSO7Q5ZrDpocvm2t6iK39b7PRgOQbr43nvw==",
       "brillig_names": [
-        "is_consumable"
+        "is_reject_all"
       ]
     },
     {
-      "name": "public_dispatch",
+      "name": "set_authorized",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -80,11 +73,18 @@
       "abi": {
         "parameters": [
           {
-            "name": "selector",
+            "name": "message_hash",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
+          },
+          {
+            "name": "authorize",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
           }
         ],
         "return_type": null,
@@ -93,38 +93,51 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "715723737710351018": {
-            "error_kind": "string",
-            "string": "rejecting all"
-          },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "5444967152290923376": {
+          "14225679739041873922": {
             "error_kind": "string",
-            "string": "Function is_consumable can only be called statically"
+            "string": "Index out of bounds"
           },
-          "6304245522015439386": {
+          "17843811134343075018": {
             "error_kind": "string",
-            "string": "Function _set_authorized can only be called internally"
-          },
-          "9474245853673257536": {
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "set_authorized"
+      ]
+    },
+    {
+      "name": "set_reject_all",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "reject",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "206160798890201757": {
             "error_kind": "string",
-            "string": "Function is_reject_all can only be called statically"
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "12737498021964987455": {
+          "5019202896831570965": {
             "error_kind": "string",
-            "string": "unauthorized"
+            "string": "attempt to add with overflow"
           },
           "14225679739041873922": {
             "error_kind": "string",
@@ -136,17 +149,18 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcBLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAgceAgACAScCAwAALQgBBCcCBQQEABABBQEnAwQEAQAoBAIFLQwFBi0OAwYAKAYCBi0OAwYAKAYCBi0OAwYrAgAFAAAAAAAAAAACAAAAAAAAAAAtCAEGJwIHBAUAEAEHAScDBgQBACgGAgctDAcILQ4DCAAoCAIILQ4DCAAoCAIILQ4DCAAoCAIILQ4FCC0IAQUAAAECAS0OBAUtCAEEAAABAgEtDgYELQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARAAHJwIIAAEnAgkECi0IAAotDAULLQwEDC0MBg0tDAcOLQwIDwAQAAkAJQAAAjAtBAAAJwIIBAktCAAJLQwFCi0MBAstDAYMLQwHDS0MAg4AEAAIACUAAAIwLQQAAC0NBwILKAACgEQACCQCAAgAAAGqJwIJBAA8CQEJJwICBAgtCAAILQwFCS0MBAotDAYLLQwHDAAQAAIAJQAAA14tBAAALQ0EAgEoAAKARgAFLQ0FBAo4BAMCCygAAoBEAAMkAgADAAAB+yUAAARxHAwBAgAwDAACAAQmKACABAR4AA0AAACABIADJACAAwAAAi8qAQABBfeh86+lrdTKPAEBAiYlAAACBy0NAwYtDQQHCygAB4BEAAgkAgAIAAACVicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAuojAAACay0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAApUlAAAEgy4EAAaAAygAgAQEAAQlAAAElS4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAALVJQAABSMtDgoBLQ4HAi0OBQMtDgkEIwAAA10nAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADXi0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABJUuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAANdJiUAAAIHLgiARQAFIwAAA24NKAAFgEMABiQCAAYAAAPeIwAAA4MtDQEFLQ0CBi0NAwctDQQILQ0GCQAoCQIJLQ4JBicCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAD/CMAAARoLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAElS4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAARoLQwGBSMAAANuKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAEsCMAAAS7LgCAA4AFIwAABSIuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFDi4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAE3SgBgAUEAAEDAIAGAAKABiMAAAUiJioBAAEFRafKcRlB5BU8AQECJg==",
+      "debug_symbols": "7Z3dbiI9DIbvhWMO8uc46a18+rSiLV0hIVrRdqVV1XvfDMsMbMepFwetVMUnFRS/xPOQiR3PJPO2uF/fvn7/ttk9PD4vbv57W2wf71Yvm8ddeff2vlzc7jfb7eb7t/N/L8zwx1pzEDw/rXbD++eX1f5lcWOzicvFenc/vHShfMXDZrte3IB5X86MwSRzNC4v02QcM2GcwMLROIE358b/L4s7QLqTUpjcMfC5O9ZEPxpb6ydjGz1lDeOBOuMmW++AsMUcRt8x55O1Gw56Zu3BHY2DjSdbQ9k6m+3ohjOZsQaXR95nBAfbAaEzirAVYVCErQizImxE6LUXNiPUXtiKMGgvbEaYFGEjQnCKsBUhKsJGhNEqwlaEURE2IkSd4P0FwoxH42hhhjDridyMUCs1jQid0RO5GaH2wlaEVnthM0Lthc0ItVLTitB5RdiKUCs1rQi9VmqaEWqlphVh0AleM0Kt1LQiBE2tPyI8YAmKhcKiKTCFJWpaS2LRJIHCgpp+klg0mFNYkgZoEovWsygsetWIxqK9hcDi9eoOjaXTSOTSeE3f+TM/Riy207GFw6K9hcLS6z3+HJagWCgsnV7VYLD0eqWCw6JDLoUl6JBLYuk0+Wew9Fr557BogCaxdFr5Z7D0WvnnsHRa+WewoM6gSSwaoEksOuRSWJIOuSQWnUFTWLL2FhJLpwEa7eQGfli3dpl1gRhMp+H8Iog2xnHrHRsxzSF2GuWuCtHq6dwO0XVabL0uxE5Ls5dBRJyOEPMsOgevgeUKEDudVV4Xokbndoih0znIdSFqitMOETSwXAGipjjtEHvdp+i6EDXFuQJETXH+AmI2ecLh5hBRo3M7xHSFMbFYj8YuAAMRII+T+ZjO9tC2BimMcbxrGs8m/hbdb+fjF3Y+h6/rPBj3lZ3nBw7vGedLIX40Dg7/aGJunbwdT8Lk3enmf3Ir+DC5EfLpi33wB9+t+9e+u+Qm30343Pdk0rSNvfXxc2Nro3HT6BuDPzcfjrWSahg3qUycrS6HSmxlVEjPl62fKo82zCqPUBk9OVWWqCrjBaeiL9HaeCKfZjRiZdshPy3rLy9nbcXKTjucCiWqSrmSU4FEFUTHVdnemFFVJnqMqjKzATf1DQg4V6FEhUGkyhJVZcUlo8pGpJK1VTmuOGVd5XT/qMJKBGJUlbGfUVUWxXAqEKlENLwXqUQMK9u3+FOW7N3s/MJKDYtTgUiVJarKTaGcCiUqFNFAEfkkaiuJyCcR+SwiX7kZxocpj/MwG22S8RJVZStLTgUSlbMiVZSoKk8C4VSSuJyCE6kk0TyBqC0kjwvDmOiVoW+moaPXqXSRYdZOpvsgo8HLNfTSX0YDAo2AAb2iktEkwbwkV2Ijp0KJqtLHOZWoLRC1BaK2oqitKGoLRb8XitqqxEZOJZlVZzqn/nR0yfSMtQwG41niCM3lZ2Nx3VzcUBEFiSgJRPSKWk4UBSCClYgkLdEr+fJUVsgIhAgEoihpKXIDNCmS9D0EgSg5iQgFouwlonS5yArygiISHJMVZAbWClKDIrq0R7yXtz9W+83qdrs+PmX04XV3d/bQ0ZefT+sPzx992j/ere9f9+vhSaSnh5AO/d55u3TgDr9KeVsgL0tHOPg2fAq+fAql1dLyLw==",
       "brillig_names": [
-        "public_dispatch"
+        "set_reject_all"
       ]
     },
     {
-      "name": "consume",
+      "name": "is_consumable",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "public",
+        "view"
       ],
       "abi": {
         "parameters": [
@@ -167,7 +181,7 @@
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "name": "message_hash",
             "type": {
               "kind": "field"
             },
@@ -176,7 +190,7 @@
         ],
         "return_type": {
           "abi_type": {
-            "kind": "field"
+            "kind": "boolean"
           },
           "visibility": "public"
         },
@@ -185,17 +199,13 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "715723737710351018": {
-            "error_kind": "string",
-            "string": "rejecting all"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "12737498021964987455": {
+          "5444967152290923376": {
             "error_kind": "string",
-            "string": "unauthorized"
+            "string": "Function is_consumable can only be called statically"
           },
           "14225679739041873922": {
             "error_kind": "string",
@@ -207,23 +217,23 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "consume"
+        "is_consumable"
       ]
     },
     {
-      "name": "is_reject_all",
+      "name": "_set_authorized",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "view"
+        "internal"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "on_behalf_of",
+            "name": "approver",
             "type": {
               "kind": "struct",
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
@@ -237,14 +247,23 @@
               ]
             },
             "visibility": "private"
+          },
+          {
+            "name": "message_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "authorize",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "boolean"
-          },
-          "visibility": "public"
-        },
+        "return_type": null,
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -254,9 +273,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "9474245853673257536": {
+          "6304245522015439386": {
             "error_kind": "string",
-            "string": "Function is_reject_all can only be called statically"
+            "string": "Function _set_authorized can only be called internally"
           },
           "14225679739041873922": {
             "error_kind": "string",
@@ -268,51 +287,121 @@
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACSR4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAnInAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGLQ0EBQAoBQIFLQ4FBCsCAAUAAAAAAAAAAAIAAAAAAAAAAC0IAQYnAgcEBQAQAQcBJwMGBAEAKAYCBy0MBwgtDgIIACgIAggtDgIIACgIAggtDgIIACgIAggtDgUILQ0EBQAoBQIFLQ4FBC0NBgUAKAUCBS0OBQYtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAAChC0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAoQtBAAALQ0HAQsoAAGARAADJAIAAwAAAeInAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADsi0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIzJQAABMUvDAADAAEcDAEDARwMAwIAHAwCAQEmKACABAR4AA0AAACABIADJACAAwAAAnEqAQABBfeh86+lrdTKPAEBAiYqAQABBYN7SGg+6XpAPAEBAiYlAAACSS0NAwYtDQQHCygAB4BEAAgkAgAIAAACqicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAz4jAAACvy0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAAuklAAAE1y4EAAaAAygAgAQEAAQlAAAE6S4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAMpJQAABXctDgoBLQ4HAi0OBQMtDgkEIwAAA7EnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADsi0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABOkuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOxJiUAAAJJLgiARQAFIwAAA8INKAAFgEMABiQCAAYAAAQyIwAAA9ctDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEUCMAAAS8LQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAE6S4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAAS8LQwGBSMAAAPCKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAFBCMAAAUPLgCAA4AFIwAABXYuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFYi4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFMSgBgAUEAAEDAIAGAAKABiMAAAV2JioBAAEFRafKcRlB5BU8AQECJg==",
-      "debug_symbols": "7Z3bbts8DMffJde5EKkj9yofPgxpmw4BgrRI2wFD0Xefk8WHRIxVU8EOMG+GeePfon6WRYmKpffFw/ru7dvXze7x6WXx5b/3xfbpfvW6edo1V+8fy8XdfrPdbr59Hf7zwhz+AENHwcvzane4fnld7V8XXwA9wnKx3j0c/+5sc5PHzXbdXBn3sczsY3Ofk3ls7DvrQIwxYcCTMWE6M/5/uQBwn/HIn3l01JFMh8LyLAp1kdO5lOxJ5ujA+KTyhiEIJrTGADB4OMFy1j6cjNFgZ2sPjyl/kOR8+yCJ+jtjSoy1jab12fYuI+cyIrQ3RrR23Ni7eLL1Lg1ND/wcKr8qfkH51fDzoPyq+Gn7q+IXtP3V8dP2V8UvGuVXxc8pvyp+pPxq+CWr/Kr4JeVXw490/lbkl9oUgk+Y8dPxSw0/NDp+ruPnlV+BX+hsw7npgR/q+1vFz+r8o46fvr9V/Jy2vzp+2v6q+Hltf3X8nPKr4qfz3yp+QfMvdfx0/byKX9T8Sx0/nb9V8Uuaf6njp+NnBoouCuVQyCmUHIoOXzMo1uiYgIGiA80cCmj0ZqBoSM6hoOapGCgakhkoGpJzKFbTRAwUDck5FKchmYGiWZocitdhPgNFW0oORT8y4KDMM/pYaF1Gi+ESykyXEwpQ5tmnjENJ85wQFqA4hZJDmeeEcBzKTH83X4CiHW0Gxc30F+4FKNpSciigIZmBMs9sfgHKPBfYx6HgPHO0BSg6S86hWA3JDBTtaBko2tHmUJxTKDkUbSk5FD/PkBxda4vRy42PBOcZv6cQhJBcW79oLr+QdmGece2GBKO+xbUE55lCvSHBNM986ySCkdqNXiBBFouTRpJKgjTPaeMtCWosriU4z2nG7Qh6o6OZWoIaSSoJgo5maglqG6wkiDqaqSWoo5kiQbJd/chlBGf6WcUtCd6gH4SU2hJweEQGS9B7ap0PCftbg4kcw9DuXRhjv/coRDw6f4vDI/6Y87fY+enPOZ/+Yec/sWcP2pLz3bsNTbrprAjGHd/lpmIwhQN1ou38iA5x3LjpsWLoHHGGhubHutJvr2vs64pm3H0f27ODfOpdt84eff/E3up/r+//LvfAL0WC6aIOmIHqVyAJ/FJdScRGHwDv+opfpnIDvyBTEPFrECVREoj4THPT23XvKZpLEJFPKoDrT58adgWtKApE/Cf/JZGXiEggQkmdrhzeNS7id/4siXgQ3nUtwke4FPFnDJVESSDiI1tJRAIR3zeXRJKS0pU6UTesDXD5cVckkIjCdFEyTiIigQisRBQFIhTQS/xOzmD76Yf1mIm8REQCkbMSURSIrrzuBZEERJAgD6KSJMijBHmUIE9XkIduhmETZKIoEPG7cJVENF1ExgtEYCSiJBChIOYSv1t+QWSNRCQpKbB1aqZs3cD68vdVxEcn6nJKFEMmiZMlfDgbl/jpEsG4H8yVAFhSJYkKrEglKgtFZaGoLCsqy4rKcqLn5URleVG9rswKCyp+k4OiyotUojeFHzOPdS+NhuVO2GYGyOWa6X0SAP8Wj5YDZrpvwK9cFjRhuobfr2ycAfrpGisox/KsU9sOzhYLWg1N1zhBOfx7PqgPo/GC9uZpuoY/63NcE0GgidM1fNanoBGUQ4L6kKBd0/Tng2ZiO/horr6v9pvV3XZ9Otv+8W13Pzjq/vXH8/ri1Pvn/dP9+uFtvz6cf98ffX94DdGlJQY69oHNZfMgl4B4rM7hf5sFNozYlNqU/BM=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "is_reject_all"
+        "_set_authorized"
       ]
     },
     {
-      "name": "sync_notes",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
-        "aztec::macros::functions::utility"
+        "public"
       ],
       "abi": {
-        "parameters": [],
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
         "return_type": null,
         "error_types": {
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "715723737710351018": {
+            "error_kind": "string",
+            "string": "rejecting all"
+          },
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "5444967152290923376": {
+            "error_kind": "string",
+            "string": "Function is_consumable can only be called statically"
+          },
+          "6304245522015439386": {
+            "error_kind": "string",
+            "string": "Function _set_authorized can only be called internally"
+          },
+          "9474245853673257536": {
+            "error_kind": "string",
+            "string": "Function is_reject_all can only be called statically"
+          },
+          "12737498021964987455": {
+            "error_kind": "string",
+            "string": "unauthorized"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
           "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": "rZLdCoMgGIbvxeMO/P/ZrYwxrCwEsbAajOjeZ2EsarSTTj789OHjUd8RlCYf6qf1VdOB230Eril0bxsfu3HKQB6sc7Z+brcBnAsiC9+12s9t1+vQgxuCFMkMGF8uayHijMo6s3RTduCF5ImW83liBfqBMswSyhj8jqV8emQA0StsJBGrDVPnNpSohFIuDzbsEhtJVxslz204XN+GY36w4VfYKIwTrQj7YyNhQgXc/dQU25cOVufOpIhVgy82ievfrdmFrw1NYcohmDmGmwTGeo93wCSOjaM/",
+      "bytecode": "JwACBAEoAAABBIBSJwAABAMnAgIEAScCAwQAHxgAAwACgFEuCIBRAAElAAAARSUAAAC4KAIAAQSAUicCAgQAOw0AAQACKQCAQwBH2s1zKACARAQAAygAgEUBAAAoAIBGBAAAKACARwAAACgAgEgBAAEoAIBJBAABKACASgQAAigAgEsEAAQoAIBMAAAEKACATQAADigAgE4AADMoAIBPAAA3KwCAUAAAAAAAAAAAAgAAAAAAAAAAJiUAABYnKQIAAgC4Od6RCjgBAgMnAgQEACcCBgQDADgEBgUtCAECABABBQEnAwIEAQAoAgIFLQ4EBQAoBQIFLQ4EBScCBQQDADgCBQQnAgQAAiQCAAMAAAEWIwAAA60tCAEDJwIFBAMAEAEFAScDAwQBACgDAgUfJIBJgEoABS0IAQUAAAECAS0OAwUtCAEDAAABAgEuCoBGAAMnAgcECC0IAAgtDAUJLQwDCi4IgEwACwAQAAcAJQAAFlAtBAAALQwJBicCCAQJLQgACS0MBQotDAMLABAACAAlAAAWyS0EAAAtDAoHJwIFBAgtCAAILQwHCQAQAAUAJQAAF0AtBAAALQwJAy0IAQUAAAECAS4KgEUABS0IAQcAAAECAS4KgEcABy0IAQgAAAECAScCCQBrLQ4JCB4CAAkBLQgBCicCCwQEABABCwEnAwoEAQAoCgILLQwLDC4KgEcADAAoDAIMLgqARwAMACgMAgwuCoBHAAwtCAELJwIMBAUAEAEMAScDCwQBACgLAgwtDAwNLgqARwANACgNAg0uCoBHAA0AKA0CDS4KgEcADQAoDQINLgqAUAANLQgBDAAAAQIBLQ4KDC0IAQoAAAECAS0OCwotCAELAAABAgEuCoBGAAstCAENAAABAgEuCoBFAA0nAg4EDy0IAA8tDAwQLQwKES0MCxItDA0TLQwEFAAQAA4AJQAAF2UtBAAAJwIOBA8tCAAPLQwMEC0MChEtDAsSLQwNEy0MCRQAEAAOACUAABdlLQQAACcCDgQPLQgADy0MDBAtDAoRLQwLEi0MDRMAEAAOACUAABiOLQQAAC0MEAkLKAAJgEcACgsoAAqARQALJAIACwAAA0MlAAAZAicCDgQPLQgADy0MBRAtDAcRLQwIEi0MCRMuCIBPABQtDAYVABAADgAlAAAZFC0EAAAtDBAKLQwRCy0MEgwtDBMNHAwDBQAwDAAFAA0AKAICBi0NBgUnAgcEAgA4BgcDOw0AAwAFIwAAA60pAgADAIlV9fwKOAEDBS0NAgMAKAMCAy0OAwInAgMAASQCAAUAAAPaIwAABQQtCAEFJwIGBAIAEAEGAScDBQQBACgFAgYfJIBJgEkABi0IAQYAAAECAS0OBQYtCAEFAAABAgEuCoBGAAUnAggECS0IAAktDAYKLQwFCwAQAAgAJQAAGugtBAAALQwKBycCBgQILQgACC0MBwkAEAAGACUAABdALQQAAC0MCQUtCAEGAAABAgEuCoBFAAYtCAEHAAABAgEuCoBHAActCAEIAAABAgEnAgkAai0OCQgeAgAJAScCDgQPLQgADy0MBhAtDAcRLQwIEi0MAxMuCIBOABQtDAkVABAADgAlAAAbRS0EAAAtDBAKLQwRCy0MEgwtDBMNHAwFBgAwDAAGAA0tDQIFACgFAgUtDgUCACgCAgctDQcGJwIIBAIAOAcIBTsNAAUABiMAAAUEKQIABQAnFrFmCjgBBQYkAgAGAAAFHyMAAAwFLQgBBicCBwQDABABBwEnAwYEAQAoBgIHHySASYBKAActCAEHAAABAgEtDgYHLQgBBgAAAQIBLgqARgAGJwIJBAotCAAKLQwHCy0MBgwuCIBNAA0AEAAJACUAAB0ZLQQAAC0MCwgnAgoECy0IAAstDAcMLQwGDS4IgEwADgAQAAoAJQAAFlAtBAAALQwMCS0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEcABy0IAQoAAAECAScCCwBdLQ4LCicCDwQQLQgAEC0MBhEtDAcSLQwKEy0MAxQuCIBOABUtDAgWABAADwAlAAAbRS0EAAAtDBELLQwSDC0MEw0tDBQOJwIQBBEtCAARLQwLEi0MDBMtDA0ULQwOFQAQABAAJQAAHZItBAAALQwSDwsoAA+ARQALJAIACwAABl4lAAAdsR4CAAsBHgIADAMeAgANBC0IAQ4nAg8EBQAQAQ8BJwMOBAEAKA4CDy0MDxAtDgsQACgQAhAtDgwQACgQAhAtDg0QACgQAhAtDgkQJwIJAC4tCAELJwIMBAYAEAEMAScDCwQBACgLAgwtDAwNLQ4JDQAoDQINLQ4JDQAoDQINLQ4JDQAoDQINLQ4JDQAoDQINLQ4JDS0IAQkAAAECAS0OCwknAgsEBS4IgEYABSMAAAcODSgABYBLAAwkAgAMAAAVyCMAAAcjLQ0JDC0IAQknAg0EBAAQAQ0BJwMJBAEAKAkCDS0MDQ4uCoBHAA4AKA4CDi4KgEcADgAoDgIOLgqARwAOKwIADQAAAAAAAAAABQAAAAAAAAAALQgBDicCDwQFABABDwEnAw4EAQAoDgIPLQwPEC4KgEcAEAAoEAIQLgqARwAQACgQAhAuCoBHABAAKBACEC0ODRAtCAENAAABAgEtDgkNLQgBCQAAAQIBLQ4OCS0IAQ4AAAECAS4KgEYADi0IAQ8AAAECAS4KgEUADy0NDBAAKBACEC0OEAwuCIBGAAUjAAAIBQw4BQsQJAIAEAAAFX4jAAAIFycCCwQQLQgAEC0MDREtDAkSLQwOEy0MDxQAEAALACUAABiOLQQAAC0MEQUtCAEJJwILBAQAEAELAScDCQQBACgJAgstDAsMLgqARwAMACgMAgwuCoBHAAwAKAwCDC4KgEcADC0IAQsnAgwEBQAQAQwBJwMLBAEAKAsCDC0MDA0uCoBHAA0AKA0CDS4KgEcADQAoDQINLgqARwANACgNAg0uCoBQAA0tCAEMAAABAgEtDgkMLQgBCQAAAQIBLQ4LCS0IAQsAAAECAS4KgEYACy0IAQ0AAAECAS4KgEUADScCDgQPLQgADy0MDBAtDAkRLQwLEi0MDRMtDAQUABAADgAlAAAXZS0EAAAnAg4EDy0IAA8tDAwQLQwJES0MCxItDA0TLQwIFAAQAA4AJQAAF2UtBAAAJwIPBBAtCAAQLQwMES0MCRItDAsTLQwNFAAQAA8AJQAAGI4tBAAALQwRDgsoAA6ARwAJCygACYBFAAskAgALAAAJkyUAABkCJwIPBBAtCAAQLQwGES0MBxItDAoTLQwOFC4IgE8AFS0MBRYAEAAPACUAABkULQQAAC0MEQktDBILLQwTDC0MFA0nAg8EEC0IABAtDAkRLQwLEi0MDBMtDA0UABAADwAlAAAdki0EAAAtDBEOJAIADgAACgwlAAAdwy0IAQknAgsEBAAQAQsBJwMJBAEAKAkCCy0MCwwuCoBHAAwAKAwCDC4KgEcADAAoDAIMLgqARwAMLQgBCycCDAQFABABDAEnAwsEAQAoCwIMLQwMDS4KgEcADQAoDQINLgqARwANACgNAg0uCoBHAA0AKA0CDS4KgFAADS0IAQwAAAECAS0OCQwtCAEJAAABAgEtDgsJLQgBCwAAAQIBLgqARgALLQgBDQAAAQIBLgqARQANJwIOBA8tCAAPLQwMEC0MCREtDAsSLQwNEy0MBBQAEAAOACUAABdlLQQAACcCDgQPLQgADy0MDBAtDAkRLQwLEi0MDRMtDAgUABAADgAlAAAXZS0EAAAnAg4EDy0IAA8tDAwQLQwJES0MCxItDA0TABAADgAlAAAYji0EAAAtDBAICygACIBHAAkLKAAJgEUACyQCAAsAAAtdJQAAGQInAg4EDy0IAA8tDAYQLQwHES0MChItDAgTLgiATwAULQwFFQAQAA4AJQAAGRQtBAAALQwQCS0MEQstDBIMLQwTDTAIgEcADScCBgQBJwIIBAMAOAYIBy0IAQUAEAEHAScDBQQBACgFAgctDgYHACgHAgctDgYHJwIHBAMAOAUHBi0MBgcuCoBDAAcAKAUCCC0NCAcnAgoEAgA4CAoGOw0ABgAHIwAADAUpAgAFAGGWa3wKOAEFBiQCAAYAAAwgIwAADwMtCAEFJwIGBAQAEAEGAScDBQQBACgFAgYfJIBJgEQABi0IAQYAAAECAS0OBQYtCAEFAAABAgEuCoBGAAUnAggECS0IAAktDAYKLQwFCwAQAAgAJQAAHdUtBAAALQwKBwEoAAeASQAJLQ0JCCcCCQQKLQgACi0MBgstDAUMABAACQAlAAAd1S0EAAAtDAsHASgAB4BJAAotDQoJJwIKBAstCAALLQwGDC0MBQ0AEAAKACUAAB3VLQQAAC0MDAcnAgYECi0IAAotDAcLABAABgAlAAAXQC0EAAAtDAsFLQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARwAHLQgBCgAAAQIBJwILAEstDgsKHgIACwEeAgAMAAo4CwwNJAIADQAADUglAAAeTC0IAQsnAgwEBAAQAQwBJwMLBAEAKAsCDC0MDA0uCoBHAA0AKA0CDS4KgEcADQAoDQINLgqARwANLQgBDCcCDQQFABABDQEnAwwEAQAoDAINLQwNDi4KgEcADgAoDgIOLgqARwAOACgOAg4uCoBHAA4AKA4CDi4KgFAADi0IAQ0AAAECAS0OCw0tCAELAAABAgEtDgwLLQgBDAAAAQIBLgqARgAMLQgBDgAAAQIBLgqARQAOJwIPBBAtCAAQLQwNES0MCxItDAwTLQwOFC0MBBUAEAAPACUAABdlLQQAACcCDwQQLQgAEC0MDREtDAsSLQwMEy0MDhQtDAgVABAADwAlAAAXZS0EAAAnAg8EEC0IABAtDA0RLQwLEi0MDBMtDA4UABAADwAlAAAYji0EAAAtDBEICygACIBHAAsLKAALgEUADCQCAAwAAA6ZJQAAGQInAg8EEC0IABAtDAYRLQwHEi0MChMtDAgULgiATwAVLQwJFgAQAA8AJQAAGRQtBAAALQwRCy0MEgwtDBMNLQwUDhwMBQYAMAwABgAOACgCAgctDQcGJwIIBAIAOAcIBTsNAAUABiMAAA8DKQIAAgBG+0TaCjgBAgUkAgAFAAAPHiMAABCgLQgBAicCBQQCABABBQEnAwIEAQAoAgIFHySASYBJAAUtCAEFAAABAgEtDgIFLQgBAgAAAQIBLgqARgACJwIHBAgtCAAILQwFCS0MAgoAEAAHACUAABroLQQAAC0MCQYBKAAGgEkABS0NBQItCAEFAAABAgEuCoBFAAUtCAEGAAABAgEuCoBHAAYtCAEHAAABAgEnAggAQi0OCAceAgAICQo4CAMJJAIACQAAD9AlAAAeXicCDAQNLQgADS0MBQ4tDAYPLQwHEC0MAxEuCIBOABItDAITABAADAAlAAAbRS0EAAAtDA4ILQwPCS0MEAotDBELJwIFBAwtCAAMLQwIDS0MCQ4tDAoPLQwLEAAQAAUAJQAAHZItBAAALQwNAhwMAgUAJwIGBAEnAggEAwA4BggHLQgBAgAQAQcBJwMCBAEAKAICBy0OBgcAKAcCBy0OBgcnAgcEAwA4AgcGLQwGBy0OBQcAKAICBy0NBwYnAggEAgA4BwgFOw0ABQAGIwAAEKApAgACAPjUXpsKOAECBSQCAAUAABC7IwAAE7EtCAECJwIFBAMAEAEFAScDAgQBACgCAgUfJIBJgEoABS0IAQUAAAECAS0OAgUtCAECAAABAgEuCoBGAAInAgcECC0IAAgtDAUJLQwCCi4IgE0ACwAQAAcAJQAAHRktBAAALQwJBicCCAQJLQgACS0MBQotDAILLgiATAAMABAACAAlAAAWUC0EAAAtDAoHLQgBAgAAAQIBLgqARQACLQgBBQAAAQIBLgqARwAFLQgBCAAAAQIBJwIJAB0tDgkIHgIACQkKOAkDCiQCAAoAABGQJQAAHnAtCAEDJwIJBAQAEAEJAScDAwQBACgDAgktDAkKLgqARwAKACgKAgouCoBHAAoAKAoCCi4KgEcACi0IAQknAgoEBQAQAQoBJwMJBAEAKAkCCi0MCgsuCoBHAAsAKAsCCy4KgEcACwAoCwILLgqARwALACgLAgsuCoBQAAstCAEKAAABAgEtDgMKLQgBAwAAAQIBLQ4JAy0IAQkAAAECAS4KgEYACS0IAQsAAAECAS4KgEUACycCDAQNLQgADS0MCg4tDAMPLQwJEC0MCxEtDAQSABAADAAlAAAXZS0EAAAnAgQEDC0IAAwtDAoNLQwDDi0MCQ8tDAsQLQwGEQAQAAQAJQAAF2UtBAAAJwIGBAwtCAAMLQwKDS0MAw4tDAkPLQwLEAAQAAYAJQAAGI4tBAAALQwNBAsoAASARwADCygAA4BFAAYkAgAGAAAS4SUAABkCJwILBAwtCAAMLQwCDS0MBQ4tDAgPLQwEEC4IgE8AES0MBxIAEAALACUAABkULQQAAC0MDQMtDA4GLQwPCS0MEAonAgQECy0IAAstDAMMLQwGDS0MCQ4tDAoPABAABAAlAAAdki0EAAAtDAwCHAwCAwAnAgQEAScCBgQDADgEBgUtCAECABABBQEnAwIEAQAoAgIFLQ4EBQAoBQIFLQ4EBScCBQQDADgCBQQtDAQFLQ4DBQAoAgIFLQ0FBCcCBgQCADgFBgM7DQADAAQjAAATsScCAgJVJwIDAm4nAgQCaycCBQJvJwIGAncnAgcCICcCCAJzJwIJAmUnAgoCbCcCCwJjJwIMAnQnAg0CcicCDgJ7JwIPAn0tCAEQJwIRBBwAEAERAScDEAQBACgQAhEtDBESLQ4CEgAoEgISLQ4DEgAoEgISLQ4EEgAoEgISLQ4DEgAoEgISLQ4FEgAoEgISLQ4GEgAoEgISLQ4DEgAoEgISLQ4HEgAoEgISLQ4IEgAoEgISLQ4JEgAoEgISLQ4KEgAoEgISLQ4JEgAoEgISLQ4LEgAoEgISLQ4MEgAoEgISLQ4FEgAoEgISLQ4NEgAoEgISLQ4HEgAoEgISLQ4OEgAoEgISLQ4IEgAoEgISLQ4JEgAoEgISLQ4KEgAoEgISLQ4JEgAoEgISLQ4LEgAoEgISLQ4MEgAoEgISLQ4FEgAoEgISLQ4NEgAoEgISLQ4PEgsggEWASAACJAIAAgAAFX0nAgMEHi0IAQQnAgUEHgAQAQUBLQwEBSoDAAUFJ0ZIsvVBF70AKAUCBQAoEAIGJwIHBBsuBAAGgAMuBAAFgAQuBAAHgAUlAAAegicCBgQbADgFBgUuCoBJAAUAKAUCBS0OAQUAKAUCBTwNBAMmACgMAhEAOBEFEi0NEhAnAhEEEi0IABItDA0TLQwJFC0MDhUtDA8WLQwQFwAQABEAJQAAF2UtBAAAASgABYBJABAtDBAFIwAACAUtDQkMASgABYBJAA0AKA4CEAA4EAURLQ0RDww4DQsQJAIAEAAAFfQlAAAeyC4EAAyAAygAgAQEAAYlAAAe2i4IgAUAEAAoEAIRADgRDRItDg8SLQ4QCS0MDQUjAAAHDigAgAQEeAANAAAAgASAAyQAgAMAABZPKgEAAQX3ofOvpa3UyjwBAQImJQAAFicnAgYEBy0IAActDAEILQwCCQAQAAYAJQAAFsktBAAALQwIBQsoAAOATAABASgABYBJAAYtDQYCJAIAAQAAFrsjAAAWmQsoAAOATQABJAIAAQAAFrInAgUEADwJAQUtDAIEIwAAFsQtDAIEIwAAFsQtDAQBJiUAABYnLQ0BAy0NAgQNKAAEgEoABSQCAAUAABbrJQAAHsgAKAMCBgA4BgQHLQ0HBS0IAQYnAgcEAgAQAQcBJwMGBAEAKAYCBy0MBwgtDgUIASgABIBJAAUOOAQFByQCAAcAABczJQAAH2gtDgMBLQ4FAi0MBgEmJQAAFicBKAABgEkAAy0NAwIcDAIDARwMAwEAHAwBAgEtDAIBJiUAABYnLQ0DBi0NBAcLKAAHgEUACCQCAAgAABeLJwIJBAA8CQEJCygABoBEAAckAgAHAAAYGiMAABegLQ0BBi0NAgctDQMILQ0ECQ0oAAiARAAKJAIACgAAF8UlAAAeyC4EAAaAAygAgAQEAAQlAAAe2i4IgAUACgAoCgILADgLCAwtDgUMASgACIBJAAUOOAgFBiQCAAYAABgFJQAAH2gtDgoBLQ4HAi0OBQMtDgkEIwAAGI0nAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAAfei0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAAHtouCIAFAAkAKAkCCgEoAAqARgALLQ4FCy0OCQEtDgcCLgqASQADLQ4IBCMAABiNJiUAABYnLQ0EBQsoAAWARQAGJAIABgAAGLAnAgcEADwJAQcnAgUEBi0IAAYtDAEHLQwCCC0MAwktDAQKABAABQAlAAAfei0EAAAtDQEFLQ0CBi0NAwctDgUBLQ4GAi0OBwMuCoBIAAQBKAAGgEkAAi0NAgEmKgEAAQUC3G4ngHYSnTwBAQImJQAAFictCAELJwIMBAQAEAEMAScDCwQBACgLAgwtDAwNLgqARwANACgNAg0uCoBHAA0AKA0CDS4KgEcADS0IAQwnAg0EBQAQAQ0BJwMMBAEAKAwCDS0MDQ4uCoBHAA4AKA4CDi4KgEcADgAoDgIOLgqARwAOACgOAg4uCoBQAA4tCAENAAABAgEtDgsNLQgBCwAAAQIBLQ4MCy0IAQwAAAECAS4KgEYADC0IAQ4AAAECAS4KgEUADicCDwQQLQgAEC0MDREtDAsSLQwMEy0MDhQtDAQVABAADwAlAAAXZS0EAAAnAgQEDy0IAA8tDA0QLQwLES0MDBItDA4TLQwGFAAQAAQAJQAAF2UtBAAAJwIGBA8tCAAPLQwNEC0MCxEtDAwSLQwOEwAQAAYAJQAAGI4tBAAALQwQBAsoAAWATgAGCygABIBHAAskAgAGAAAarSMAABpqCygABYBPAAYkAgAGAAAagycCDAQAPAkBDAsoAAuARQAFJAIABQAAGpglAAAZAi0MAQctDAIILQwDCS0MBAojAAAa1wsoAAuARQAFJAIABQAAGsIlAAAZAi0MAQctDAIILQwDCS0MBAojAAAa1y0MCgQtDAcBLQwIAi0MCQMmJQAAFictDQEDLQ0CBAsoAASARgAFJAIABQAAGwolAAAeyAEoAAOASQAFLQ0FBC0IAQUnAgYEAgAQAQYBJwMFBAEAKAUCBi0MBgctDgQHLQ4DAS4KgEkAAi0MBQEmJQAAFictCAELJwIMBAQAEAEMAScDCwQBACgLAgwtDAwNLgqARwANACgNAg0uCoBHAA0AKA0CDS4KgEcADS0IAQwnAg0EBQAQAQ0BJwMMBAEAKAwCDS0MDQ4uCoBHAA4AKA4CDi4KgEcADgAoDgIOLgqARwAOACgOAg4uCoBQAA4tCAENAAABAgEtDgsNLQgBCwAAAQIBLQ4MCy0IAQwAAAECAS4KgEYADC0IAQ4AAAECAS4KgEUADicCDwQQLQgAEC0MDREtDAsSLQwMEy0MDhQtDAQVABAADwAlAAAXZS0EAAAnAgQEDy0IAA8tDA0QLQwLES0MDBItDA4TLQwGFAAQAAQAJQAAF2UtBAAAJwIGBA8tCAAPLQwNEC0MCxEtDAwSLQwOEwAQAAYAJQAAGI4tBAAALQwQBAsoAAWATgAGCygABIBHAAskAgAGAAAc3iMAABybCygABYBPAAYkAgAGAAActCcCDAQAPAkBDAsoAAuARQAFJAIABQAAHMklAAAZAi0MAQctDAIILQwDCS0MBAojAAAdCAsoAAuARQAFJAIABQAAHPMlAAAZAi0MAQctDAIILQwDCS0MBAojAAAdCC0MCgQtDAcBLQwIAi0MCQMmJQAAFicnAgYEBy0IAActDAEILQwCCQAQAAYAJQAAFsktBAAALQwIBQsoAAOATAABASgABYBJAAYtDQYCJAIAAQAAHYQjAAAdYgsoAAOATQABJAIAAQAAHXsnAgUEADwJAQUtDAIEIwAAHY0tDAIEIwAAHY0tDAQBJiUAABYnLwwABAAFHAwFBgEcDAYEABwMBAUBLQwFASYqAQABBQnuwvKHilKqPAEBAiYqAQABBbDErvb+drw/PAEBAiYlAAAWJy0NAQMtDQIEDSgABIBEAAUkAgAFAAAd9yUAAB7IACgDAgYAOAYEBy0NBwUtCAEGJwIHBAIAEAEHAScDBgQBACgGAgctDAcILQ4FCAEoAASASQAFDjgEBQckAgAHAAAePyUAAB9oLQ4DAS0OBQItDAYBJioBAAEFV30t5qSTyho8AQECJioBAAEFg3tIaD7pekA8AQECJioBAAEFS5Boxr34g3A8AQECJgEAgAOABYAHLgCAA4AILgCABIAJCwCACIAHgAokAIAKAAAexy4BgAiABi4CgAaACQEAgAgAAoAIAQCACQACgAkjAAAeliYqAQABBcVrxFoOEAACPAEBAiYuAYADgAYLAIAGAAKAByQAgAcAAB71IwAAHwAuAIADgAUjAAAfZy4AAAGABQEAAAGABAABAQCAA4AEgAkuAIADgAouAIAFgAsLAIAKgAmADCQAgAwAAB9TLgGACoAILgKACIALAQCACgACgAoBAIALAAKACyMAAB8iKAGABQQAAQMAgAYAAoAGIwAAH2cmKgEAAQVFp8pxGUHkFTwBAQImJQAAFicuCIBGAAUjAAAfig0oAAWARAAGJAIABgAAH/UjAAAfny0NAQUtDQIGLQ0DBy0NBAgtDQYJACgJAgktDgkGLQgBCScCCgQFABABCgEnAwkEAQAoBgIKJwILBAQAKAkCDD8PAAoADC0OBQEtDgkCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBJAAYkAgAHAAAgEyMAACB/LQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAe2i4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAACB/LQwGBSMAAB+K",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "public_dispatch"
       ]
     },
     {
-      "name": "set_reject_all",
+      "name": "utility_is_consumable",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "utility"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "reject",
+            "name": "on_behalf_of",
             "type": {
-              "kind": "boolean"
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ]
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "message_hash",
+            "type": {
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
-        "return_type": null,
+        "return_type": {
+          "abi_type": {
+            "kind": "boolean"
+          },
+          "visibility": "public"
+        },
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -332,17 +421,17 @@
           }
         }
       },
-      "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcBLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAi4eAgACAScCAwAALQgBBCcCBQQEABABBQEnAwQEAQAoBAIFLQwFBi0OAwYAKAYCBi0OAwYAKAYCBi0OAwYtDQQFACgFAgUtDgUEKwIABQAAAAAAAAAAAgAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OAwgAKAgCCC0OAwgAKAgCCC0OAwgAKAgCCC0OBQgtDQQFACgFAgUtDgUELQ0GBQAoBQIFLQ4FBi0IAQUAAAECAS0OBAUtCAEEAAABAgEtDgYELQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARAAHJwIIAAEnAgkECi0IAAotDAULLQwEDC0MBg0tDAcOLQwIDwAQAAkAJQAAAlctBAAAJwIIBAktCAAJLQwFCi0MBAstDAYMLQwHDS0MAg4AEAAIACUAAAJXLQQAAC0NBwILKAACgEQACCQCAAgAAAHRJwIJBAA8CQEJJwICBAgtCAAILQwFCS0MBAotDAYLLQwHDAAQAAIAJQAAA4UtBAAALQ0EAgEoAAKARgAFLQ0FBAo4BAMCCygAAoBEAAMkAgADAAACIiUAAASYHAwBAgAwDAACAAQmKACABAR4AA0AAACABIADJACAAwAAAlYqAQABBfeh86+lrdTKPAEBAiYlAAACLi0NAwYtDQQHCygAB4BEAAgkAgAIAAACfScCCQQAPAkBCQsoAAaAQwAHJAIABwAAAxEjAAACki0NAQYtDQIHLQ0DCC0NBAkNKAAIgEMACicCCwEBJAIACgAAArwlAAAEqi4EAAaAAygAgAQEAAQlAAAEvC4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAL8JQAABUotDgoBLQ4HAi0OBQMtDgkEIwAAA4QnAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAADhS0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAABLwuCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAOEJiUAAAIuLgiARQAFIwAAA5UNKAAFgEMABiQCAAYAAAQFIwAAA6otDQEFLQ0CBi0NAwctDQQIJwIJBAQtCAEKJwILBAUAEAELAScDCgQBACgGAgsnAgwEBAAoCgINPw8ACwANLQ0KBgAoBgIGLQ4GCi0OBQEtDgoCLQ4HAy0OCAQmLQ0DBgw4BQYHASgABYBGAAYkAgAHAAAEIyMAAASPLQ0BBy0NAggtDQMJLQ0ECgAoCAIMADgMBQ0tDQ0LACgHAg0AOA0FDi0NDgwAOAsMDS4EAAiAAygAgAQEAAUlAAAEvC4IgAUACwAoCwIMADgMBQ4tDg0OLQ4HAS0OCwItDgkDLQ4KBCMAAASPLQwGBSMAAAOVKgEAAQUC3G4ngHYSnTwBAQImKgEAAQXFa8RaDhAAAjwBAQImLgGAA4AGCwCABgACgAckAIAHAAAE1yMAAATiLgCAA4AFIwAABUkuAAABgAUBAAABgAQAAQEAgAOABIAJLgCAA4AKLgCABYALCwCACoAJgAwkAIAMAAAFNS4BgAqACC4CgAiACwEAgAoAAoAKAQCACwACgAsjAAAFBCgBgAUEAAEDAIAGAAKABiMAAAVJJioBAAEFRafKcRlB5BU8AQECJg==",
-      "debug_symbols": "7Z3Rbts6DIbfJde5ECVKovoqBwdD2qZDgCAt0nbAUPTd52Sxk0aUBVPBhsG8GZaWv0V/lUWKjqSPxeP6/v37t83u6fl1cfffx2L7/LB62zzvuk8fn8vF/X6z3W6+f7v88cIc/gEwR8Hry2p3+Pz6ttq/Le4gmbBcrHePh/9a7C7xtNmuF3fefC4zYySHJ2MktINxSIwx+WhPxuQpXhr/v+zc8aw7RDi4Y/y4O2CC640B3GAMwXHWvr9Ra86uO+sZ25jQn4xjSucrWyLG2kXTU3FngpZz2VroL2ytc+PGHuPJ1iNdmh74WaP8mvih8mvil5RfCz+n/a+Nn/a/Jn6o/a+NHym/Fn7eKr8mflH5tfALoPya+AXl18Iv6vytyo+g50c244fKr4mf5s9N/Mgpvwq/MNiGr6YdP2v0+W3jp/OPJn6gz28bP+1/Tfys9r82ftr/mvg5rb+08dP5bxM/1PpLGz99f97Ez2v9pY0fKr8mflp/aeIXNH9moOhLoRxK1EyXgaLpaw6FNCdgoGiiyUDR6J1DSRqSGShap8qgOKMhmYGiITmHAlomYqBoSGagaEjOoegqBwaK0zSfgaI9hYGiY0oOZaZvHhz0LnfvTsM1lJm+TqhA0Z7CQJnnmDIOZabV/AqUeVbzx6HEeU4IK1B0oGWg6ECbQyFUKDkU7Sk5lJlW8ytQ5lnNH4WCM63mV6DMs5o/DgV0lsxA0ZDMQNGBNodidaBloOgsOYcy09UdFSjzDMkRe1sbvdz4QBDnGb+nEIRwhhGNzQjOM67dkKDXp7iR4Ey3vrklwXnWWycRjKnf/QYIslg80+1vbkkQlWAjQY3FjQRpntOMWxLUbKaRYNJI0kpQs5k2gt5oH2wliEqwkaBmM1WCyQ33lzAjCBqLGwne4lCKzro3tugrBL1PvfOBLo4vARM5hqHf0DHG84asEO1v5/0/7Lxz/7Dzt9gL6O85Xx81Lr5DzzuPpm8BuvdZX5rIrcnE/hkkQ+dLs6fw4OAGpvOFHbqj7x7+uO8uDL57Gvc9kks9eEpm3BgAyQ9Dr794+/P7wKFQyDDMMPqBoXQ1oIVCUB0XAT8rBj9QPcL5KioMnRURCUSFoaIi4t+yAg2nR1mTgfC8e2gvekzWUrASURCICjXIiggFIpLcE0WBqDCXGxXFwvTF49AjfIRMFASiwq6rFREJRIWVjxVREoicpCVXuKc0pFcBrldexUKoGRcVxviKKAlEASUiCYjClj4VkYReYfcTd06Dnc+ep0JJqiJCiYimi6jwfc2KKAhEYCQiAXKykpYsSkQS5E6CvPB9FReGTNfR9cBCaCWiJBAVdgAcFwUjEXmBKDqJSBBziUAiEgRqSoKWErD3FEOfwnbj9rWEj05pqG2keD31T3y/G5eEyRJ+me24RJD3p0L8GxcVFjFWRIIZRoqSlqKkJZK0RJKWkqSlJPg7gTFOpCKJqjAZrKmCRFUIgjUVilRp6qgChp95JtvP2xMymslDERj+6R1vJwh84xfojmv49asVjZ/OgIxAI2mHZ019P/hSqz5p+FS3opneDvDP+cX9cJrp/Q34FRzjGgsCTZiucVagidM1KGgHBfczPQM4VLYEmon94LP79GO136zut+vTYexP77uHi7PZ336+rK+OaX/ZPz+sH9/368OB7eez2g+3aLvh1wY49v3uY/fHX3Z1uaNrh98G2/0Wu1a7ln8B",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "set_reject_all"
+        "utility_is_consumable"
       ]
     },
     {
-      "name": "utility_is_consumable",
+      "name": "consume",
       "is_unconstrained": true,
       "custom_attributes": [
-        "utility"
+        "public"
       ],
       "abi": {
         "parameters": [
@@ -363,7 +452,7 @@
             "visibility": "private"
           },
           {
-            "name": "message_hash",
+            "name": "inner_hash",
             "type": {
               "kind": "field"
             },
@@ -372,7 +461,7 @@
         ],
         "return_type": {
           "abi_type": {
-            "kind": "boolean"
+            "kind": "field"
           },
           "visibility": "public"
         },
@@ -381,10 +470,18 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
+          "715723737710351018": {
+            "error_kind": "string",
+            "string": "rejecting all"
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "12737498021964987455": {
+            "error_kind": "string",
+            "string": "unauthorized"
+          },
           "14225679739041873922": {
             "error_kind": "string",
             "string": "Index out of bounds"
@@ -395,10 +492,10 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "utility_is_consumable"
+        "consume"
       ]
     },
     {
@@ -2012,8 +2109,8 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7VvbTus4FP2XPvfB+77Nr4xGR1x6jiohQFxGGiH+fZzO2AnFScaCQg/NC8LtWo73Wk68vZ0+r642F0+/fmxvft4+rM7+eF5d316eP25vb1LreQW8++zh7vymaz48nt8/rs5Q2Narzc1V+lcBX9arn9vrzeoMAr+s36KRQ0aj9miTCphClP/ABOrTYJAIeSDpfwoFju41vIpnuJoVNIVq76SU0QzhFfrP9QpkkWZMGl2kGZPGjlwa4V6aAbwuDQJqHgmwvFMaX6QZkyZWpWGHXhqakYYB8vgZpL9EiiRdAcPBrwC1K5BpzB44auF09IpKzsUDij6AYw0eFbLB6X/HabhjQTsKzvhrkTPaYqQZNFmelkzcY2tBIkGeCkgDRbCuCJV5Q8MxV8Gh3BwQPA7BnT+4+HPU/tDiz//yx/olwGQGDBZLKuCg7/KHF3+O2h/5AH9ixLJMB/EZf9hDLHAfxDoCZ9cCl2DDBbSio0vRMSW009nLqXuvi/cn670t3p+s93703ktfi2ARnfaezIvk0O/G2HbBxuMPVvuJrnMTHRStJM/KA3P/3VBSOLF44ZvFa4PCmqnLfrx4YvHSl8YrYfBIqcJNcrTmg2rZ7klLfOSDTythXghZh4NfVtj3rLAkx+47hLrv3eA/f1sggbUfvNEQ3o3o85NVoQhlRMwzRQQMgKUeH3DuEXnqd4cvdn4nO+Ni5zeykz9/A5Es9N5OC9PwdOSYNwQSBylXPb10KcLEQS4KsssuGY48WA2ep5dCwJkiSJd75znTpep7uTTjSUVb3zk4ZRKlk4KZaNP0KVkV+OAsoWO+7Vspa0MGMJ0if+kLF8yLNqPayKLNqDa6aDOqjR27Nl/3qg77os2oNnHRZkwbCR+hTZ+xQKQ4o83UYYLABwwncm9VjDo9HIgpxy0JrIK8LycS/N0DoM8PwLBsl6IPilPVAKKUl08AfTCB0nxOrYv77fX19tePV++Th+5PPe0QyhtdMd2fjvXVeJpi7RRvp8RGSmpBh6y/zqWU/fIgAyKNv2E0TZF2irZTrJ3i7ZSq1I6Fwr5PqR8RTlOgnYLtFGqncDtF2inaTrF2irdT6u57XrA9xleUWi5Q3va2vsiUVuXxWtDHdQ+H7R4P2z0dtns+bPdy2O71sN3bB3bv9KZ7P2z38aDd15PmWNLySLb/HKknttMUbKdQO4XbKdJO0XaKNVPU2ymxmWLt7lu7+9buvrW7b+3uW/0HiOWQBtX27xfTdoq1U+o/5LJyMhXf3MgWmyke2inQTsF2CrVTuJGSWrjbRVQjUsllAI1hf8dS/53PNIXaKdxOkXaKNlJSizrkyO+aHfIGHl0H1O4ILbV42b2m5WCnX5XIVoRHfnldEEjNv87vt+cX15uuEtB9+3RzmQsDqfn4913+JpcO7u5vLzdXT/ebrojQ1w+62ZjKeowpAuieAgJr0bKz3n2ksFbtvu9ukBjWEcs909HTToNipqczYpZ+anQfga4RiuXjF5TCQFhj+uglhfoP",
+      "bytecode": "H4sIAAAAAAAA/+2dBXgUV9uGZ3eTQAIhuEtwEmw1u4sGSYK7U2GTbEraAEVCoZq6UncFKrTUlXqpt9Rb6kZb6u5O/+f92GlOhkkqORN4/jLXdV87tjP3e2bmjJ05x2Vs78Iew2jg2d7vAp7ErxtkWsaZv2p/ss18DWzGpduMy7AZ18RmXEuQaxnXyWa+TJtxnW3GdbEZ19NmXHbiV+3M4dzEb8CbEwzGw/64L+CLef3RwkjIGwwV5kR8EV8oEir2RwKBeCQYCUcLo2Fv1BcMxH0loWigxLu9+8NduSxvrTp/kZOekij/0jNoHSFuTUGS4irpsC3R38uo7M9S+sVhm/o/DLuBByR5KsebnceSBt7adb5sjctyefRtm2SPNi/bbZPsqdwGbqXfo/QnWbZNCobrgfog1WbbuDVvm54a9/U0j8btbFTmJ7LcTEs66D5OG2hz9xfb7QsNlG0u3Z/7hVH9cdoQw+mgEciog+M0ReP2a6jxOG3s8HHaWNk26Up/I6U/w7JtmmC4KWgGmttsG937ZwuNaeCkZ8t/7+m3jvir810TZfu0UPpbWrZVKwy3Bm1A28S2Mqd5jOq7XD3p7TOv/WpKd2/tOl+TOto/vLXrfK2c8EwyKi+qDYcTupfhTELr2umKwuFIMOoL021EBzzTPLv2tjI93coy2yVypPbWu8d2NldBuq8G22k8a3dw6GqwQyIdkhLxW3NWJ3ak9pqvQExHs7+jGVxNp7uOf/N010kSCHQGXergFqK9xp2mE0nO0lFDzLGIPxTwR+I1edY2Pbvqu60pcdKz27/3DFhH2B1HXT32j0nUS8huluOoO4Z7gJ6gl3LZ6DHqJtPp7vDZS3tG0EFjRpDl0Nkjqw6eJWTrO+gKnfTsrcEzxxfNySkMFznp2effe4asI+wyh2wlE+hdTUbRx5I59MVwP9AfeOvg2UyWxmX11Xic+hzKpHblZ9D9NKaf3+FnWz5lf/Yr/f2Vfq9l3w5gOAhCIEc58SUZdfK8JOgydjyedK3Dml8xPB7Q7ZhF4JhtOJOv6PYMsF2kZWnMvMIOXaSFlVv8ZMM+M9C9IV3Gf3uH057JkHh6jDo+gGtdokBj8L0dCl53zBoPTl8fkpjdGmPuSxKzxoPR16+OYvbWrvP115h+KSSZrtfg8PSRePpJPAMknkESzxCJZw6JZ5jEM0LiGSXxHEDiOZDEcxCJ52ASzyEknkNJPHNJPIeReA4n8RxB4jmSxDOPxDOfxLOAxHMUiedoEs8xJJ5jSTzHkXiOJ/GcQOI5kcRzEonnZBLPKSSeU0k8p5F4TifxnEHiOZPEcxaJ52wSzzkknnNJPPcg8dyTxHMvEs+9STznkXjGSDwLSTyLSDyLSTzjJJ4lJJ77kHjOJ/EsJfHcl8RzPxLPMhLPBSSeC0k8F5F47k/iuZjEcwmJ51ISz2UknuUknstJPA8g8VxB4rmSxPNAEs+DSDwPJvE8hMTzUBLPw0g8K0g8DyfxPILE80gSz6NIPI8m8TyGxPNYEs/jSDyPJ/E8gcTzRBLPk0g8V5F4nkzieQqJ56kknqeReJ5O4nkGieeZJJ5nkXieTeJ5DonnuSSe55F4nk/ieQGJ54UknheReF5M4nkJiedqEs81JJ5rSTwvJfG8jMTzchLPK0g815F4XknieRWJ53oSz6tJPK8h8byWxPM6Es/rSTxvIPG8kcTzJhLPm0k8byHxvJXE8zYSzw0knreTeN5B4nknieddJJ53k3jeQ+J5L4nnfSSeG0k87yfxfIDE80ESz4dIPB8m8XyExPNREs/HSDwfJ/HcROL5BInnkySeT5F4Pk3i+QyJ57Mkns+ReD5P4vkCiedmEs8XSTxfIvF8mcTzFRLPV0k8XyPxfJ3E8w0SzzdJPN8i8XybxHMLiec7JJ7vkni+R+K51SFPt2bP95Vl1bbt3u4ejpg/0BhzB5L2ij80ODw/IvH8mMTzExLPT0k8PyPx/JzE8wsSzy9JPL8i8fyaxPMbEs9vSTy/I/H8nsTzBxLPH0k8fyLx/JnE8xcSz19JPH8j8fydxHMbiecfJJ6yQAZPF4mnm8TTQ+KZROKZTOKZQuJZj8SzPolnKolnGolnAxLPhiSe6SSejUg8M0g8G5N4NiHxbEri2YzEs7lDntZ35LV9r+3SGHMLkph7aYy5Jcn+2MpV+/TzRyLhwpx4zEnP1i5927mmfchbu87XRqNnK5LyNG01xtyeJOZ2GmNOI4m5vcaY25GUm+pAko93JPHsROKZSeLZmcSzC4lnVxLPbiSe3Uk8e5B49iTx7EXimUXimU3i2ZvEsw+JZ18Sz34knv1JPL0knj4STz+JZ4DEM0jiGSLxzCHxDJN4Rkg8oySeA0g8B5J4DvoPvgcc/B+MeQhJzB6NMQ+to5i9tet8uRrfZwRI3uEM0xhzFsk7nOEk54QRJJ4jSTzzSDzzSTwLSDxHkXiOJvEcQ+I5lsRzHInneBLPCSSeE0k8J5F4TibxnELiOZXEcxqJ53QSzxkknjNJPGeReM4m8ZxD4jmXxHMPEs89STz3IvHcm8RzHolnjMSzkMSziMSzmMQzTuJZQuK5D4nnfBLPUhLPfUk89yPxLCPxXEDiuZDEcxGJ5/4knotJPJeQeC4l8VxG4llO4rmcxPMAEs8VJJ4rSTwPJPE8iMTzYBLPQ0g8DyXxPIzEs4LE83ASzyNIPI8k8TyKxPNoEs9jSDyPJfE8jsTzeBLPE0g8TyTxPInEcxWJ58kknqeQeJ5K4nkaiefpJJ5nkHieSeJ5Fonn2SSe55B4nkvieR6J5/kknheQeF5I4nkRiefFJJ6XkHiuJvFcQ+K5lsTzUhLPy0g8LyfxvILEcx2J55UknleReK4n8byaxPMaEs9rSTyvI/G8nsTzBhLPG0k8byLxvJnE8xYSz1tJPG8j8dxA4nk7iecdJJ53knjeReJ5N4nnPSSe95J43kfiuZHE834SzwdIPB8k8XyIxPNhEs9HSDwfJfF8jMTzcRLPTSSeT5B4Pkni+RSJ59Mkns+QeD5L4vkciefzJJ4vkHhuJvF8kcTzJRLPl0k8XyHxfJXE8zUSz9dJPN8g8XyTxPMtEs+3STy3kHi+Q+L5LonneySeW0k83yfx/IDE80MSz49IPD8m8fyExPNTEs/PSDw/J/H8gsTzSxLPr0g8vybx/IbE81sSz+9IPL8n8fyBxPNHEs+fSDx/JvH8hcTzVxLP30g8fyfx3Ebi+QeJp+Hm8HSReLpJPD0knkkknskknikknvVIPOuTeKaSeKaReDYg8WxI4plO4tmIxDODxLMxiWcTEs+mJJ7NSDybk3i2IPFsSeLZisSzNYlnGxLPtiSe7Ug825N4diDx7Eji2YnEM5PEszOJZxcSz64knt1IPLuTePYg8exJ4tmLxDOLxDObxLM3iWcfEs++JJ79SDz7k3h6STx9JJ5+Es8AiWeQxDNE4plD4hkm8YyQeEZJPAeQeA4k8RxE4jmYxHMIiedQEs9cEs9hJJ7DSTxHkHiOJPHMI/HMJ/EsIPEcReI5msRzDInnWBLPcSSe40k8J5B4TiTxnETiOZnEcwqJ51QSz2kkntNJPGeQeM4k8ZxF4jmbxHMOiedcEs89SDz3JPHci8RzbxLPeSSeMRLPQhLPIhLPYhLPOIlnCYnnPiSe80k8S0k89yXx3I/Es4zEcwGJ50ISz0UknvuTeC4m8VxC4rmUxHMZiWc5iedyEs8DSDxXkHiuJPE8kMTzIBLPg0k8DyHxPJTE8zASzwoSz8NJPI8g8TySxPMoEs+jSTyPIfE8lsTzOBLP40k8TyDxPJHE8yQSz1UknieTeJ5C4nkqiedpJJ6nk3ieQeJ5JonnWSSeZ5N4nkPieS6J53kknueTeF5A4nkhiedFJJ4Xk3heQuK5msRzDYnnWhLPS0k8LyPxvJzE8woSz3UknleSeF5F4rmexPNqEs9rSDyvJfG8jsTzehLPG0g8byTxvInE82YSz1tIPG8l8byNxHMDieftJJ53kHjeSeJ5F4nn3SSe95B43kvieR+J50YSz/tJPB8g8XyQxPMhEs+HSTwfIfF8lMTzMRLPx0k8N5F4PkHi+SSJ51Mknk+TeD5D4vksiedzJJ7Pk3i+QOK5mcTzRRLPl0g8XybxfIXE81WHPN0Wz4A3JxiMh/1xX8AX8/qjhZGQNxgqzIn4Ir5QJFTsjwQC8UgwEo4WRsPeqC8YiPtKQtFASWLZPTXG/FodxeytXed73a0v/cIeju2cpDH93iDZt5M1xvwmScwpGmN+iyTmehpjfpsk5voaY95CEnOqxpjfIYk5TWPM75LE3EBjzO+RxNxQY8xbSWJO1xjz+yQxN9IY8wckMWdojPlDkpgba4z5I5KYm2iM+WOSmJtqjPkTkpibaYz5U5KYm2uM+TOSmFtojPlzkphbaoz5C5KYW2mM+UuSmFtrjPkrkpjbaIz5a5KY22qM+RuSmNtpjPlbkpjba4z5O5KYO2iM+XuSmDtqjPkHkpg7aYz5R5KYMzXG/BNJzJ01xvwzScxdNMb8C0nMXTXG/CtJzN00xvwbSczdNcb8O0nMPTTGvE1jzB5jexmfzYmAe4M+oC/oB/rLOoAP+CUdQBCEQA4IgwiIggFgIBgEBoMhYGgi7mFgOBgBRoI8kA8KwCgwGowBY8E4MB5MABPBJDAZTAFTwTQwHcwAM8EsMBvMAXPBHmBPsBfYG8wDMVAIikAxiIMSsA+YD0rBvmA/UAYWgIVgEdgfLAZLwFKwDJSD5eAAsAKsBAeCg8DB4BBwKDgMVIDDwRHgSHAUOBocA44Fx4HjwQngRHASWAVOBqeAU8Fp4HRwBjgTnAXOBueAc8F54HxwAbgQXAQuBpeA1WANWAsuBZeBy8EVYB24ElwF1oOrwTXgWnAduB7cAG4EN4GbwS3gVnAb2ABuB3eAO8Fd4G5wD7gX3Ac2gvvBA+BB8BB4GDwCHgWPgcfBJvAEeBI8BZ4Gz4BnwXPgefAC2AxeBC+Bl8Er4FXwGngdvAHeBG+Bt8EW8A54F7wHtoL3wQfgQ/AR+Bh8Aj4Fn4HPwRfgS/AV+Bp8A74F34HvwQ/gR/AT+Bn8An4Fv4HfwTbwB5ADzAXcwAOSQDJIAfVAfZAK0kAD0BCkg0YgAzQGTUBT0Aw0By1AS9AKtAZtQFvQDrQHHUBH0Alkgs6gC+gKuoHuoAfoCXqBLJANeoM+oC/oB/oDL/ABPwiAIAiBHBAGERAFA8BAMAgMBkPAUJALhoHhYAQYCfJAPigAo8BoMAaMBePAeDABTASTwGQwBUwF08B0MAPMBLPAbDAHzAV7gD3BXmBvMA/EQCEoAsUgDkrAPmA+KAX7gv1AGVgAFoJFYH+wGCwBS8EyUA6WgwPACrASHAgOAgeDQ8Ch4DBQAQ4HR4AjwVHgaHAMOBYcB44HJ4ATwUlgFTgZnAJOBaeB08EZ4ExwFjgbnAPOBeeB88EF4EJwEbgYXAJWgzVgLbgUXAYuB1eAdeBKcBVYD64G14BrwXXgenADuBHcBG4Gt4BbwW1gA7gd3AHuBHeBu8E94F5wH9gI7gcPgAfBQ+Bh8Ah4FDwGHgebwBPgSfAUeBo8A54Fz4HnwQtgM3gRvAReBq+AV8Fr4HXwBngTvAXeBlvAO+Bd8B7YCt4HH4APwUfgY/AJ+BR8Bj4HX4AvwVfga/AN+BZ8B74HP4AfwU/gZ/AL+BX8Bn4H28AfQC4mXMANPCAJJIMUUA/UB6kgDTQADUE6aAQyQGPQBDQFzUBz0AK0BK1Aa9AGtAXtQHvQAXQEnUAm6Ay6gK6gG+gOeoCeoBfIAtmgN+gD+oJ+oD/wAh/wgwAIghDIAWEQAVEwAAwEg8BgMAQMlWsVMAwMByPASJAH8kEBGAVGgzFgLBgHxoMJYCKYBCaDKWAqmAamgxlgJpgFZoM5YC6QtualHXdpI13aH58HpN1saZNa2nuWtpSlnWJpA1ja15W2a6VdWGlzVdozlbZCpR1OaeNS2o+Uthml3UNpU1Da65O28KSdOWnDTdpHk7bHpF0vaTNL2qOStp6kHSVpo0ja/6kA0m6NtAkj7a1IWybSToi0wSHtW0jbEdIug7R5IO0JSF39Ug++1DEv9bdL3ehS77jU6S31ZUtd1FLPs9ShLPUTS92/Uq+u1Fkr9cFKXatSj6nUESr1b64GUm+k1Mko9R1KXYJST5/UgSf1y0ndbVIvmtQ5JvV5SV1ZUg+V1PEk9SdJ3URS74/UqSP11UhdMFLPitRhIvWDSN0bUq+F1Bkh9TFIXQdSj4B8oy/fv28E8t22fBMt3xvLt7zynax8gyrfd8q3k/JdonzzJ9/Tybdq8h2YfGMl3y/Jt0Hy3Y180yLfi8i1qnznIN8QSPl8Kfsu5cqlnLWUYZZyuFIuVcppSrnFLUDKtUk5Lyn3JOWApFyMlBORchNSjkDeq8t7ZnnvKu8h5b2cvKeS9zbyHkOe68tzbnnuK89B5bmgPCeT50byHEWeK8h9ttx3yn2Y3JfIdbp7++nfkHLG0vU2KrtE1mB4EtOlXK6UU5Vym1KOUcr1STk3Kfcl5aCkXJCUk5FyI1KOQsoVyHt2ee8s72HlvaS8p5P3VvIeR95ryHN+ee4tz4Hluag8J5TnZpmgM+gC5L5b7kPlvkzuU6Tsey+QBbKNHbtkpb954rfF1mFtFm9al6fOl1nDtG6J3w25a9ZmrV81Up2WXcP/gtVMS0n8RhO/qYlfd+JX0lrSOTcx7K1d50tVlqt7+RFvMJxqVO00+wdSjar7pVPLT3Zm+f8r2yzdyIrK5auxmOv1WOaz/kempyf6XcaO85hxOLEfYTuHHE4nn7n8eg5tZzPdUpS089jEZK4/3bKtzOl2v+ayrNPMdaUZju7DvppiU/3NfaOxZX5rGlS3rJR/uKyduU3VtFa36f/mqaic5rZMS1KmpVimJVfsGKOc/zKV+azHYJJlmrmfSJdfUbmM3sry+iT6zfRzMu92Ks+QrpmNv7ou6epVVKaHmTYeZZyZ5uY2qK/Ob5mWqkxLqqi6nrTEcJKyHnVZpkeyZX7zHJ+R+E1R/mP+v7HN+lMs66/ibTPOmi6pNvOn2swv+2jXRH+DBLIPBZTlVXeMuI0dl5dh7JgfmP91+Hj2m65JNq5q/mKuX641WyT6ly5btCQ+emHeinhR+bLSRQtHxIrmxw1Lpx586o5pvfhVE0AN1G4ZHuX/dp1sEPMiKami6v9yE+O9tejCEa/XXLd5QCRbPA3L+pMt80cSw2lKXOZvbT48LAnHfCWBWEksFCsuDhbFmlqWbxiVO56k05xEP/lFcWFdXRSnOLP8kMMHuu1Fsd0Bbu7DeRWVaZlXUdXJnKdAmaegmnlGKfOMUuaRrqaLa+uJXfWo6cRudxFZYJmm5jOmk2TgZsYm/S0VR+lGV1S6uyzTxijTTN9Ui6Pm/T3q8E2av5mNv7ku84Q3wKiaruoJ78+TquH8Bam6PsOwvzEw159mOHoc/3ljUM/iU93FvJxQmyX6i2JlZZOWlC6PLYvnly8sknOqGoK6WLdNiNbToTmP9bTqsgy7LcPW0631fizZZrnV/d86rqZD31XNr2Hzf8PY8X5I/V+KZT1uDetx8pCWrrFhf2+grtuhwz1klzUaljRUDxnrdlQPb+u+adikr6HMY8akfp+dbjOf1UfdDinK8tU47LaX3f1qssWxuqzPHO/ws5kcuyzVGr+a5tbtUV+Z9k+3h3qfnass1zqf1ae6+3/rsemxTLO7d2e4hB+aGN7Zl/DqqTjD2HHfdVmmqdvJmrc5tD//eZ9p7s9mWld3HNr5GPp8fMkWn1GJX0nLaZa0s7uPV/cTt2X+mk79arx29/31LPHvjMsUdXtY83wzX0kxan7ul2yZf1LiV4ZnJvrtztseyzS3zbLt8hQzDeV40H08FoVyCouCoZg37pNB/18dj7rXj1WHi2Jhny8a9MWDvtBfrb9fop/8lj6nrm7pnUwfu+sPTcu3vaW3u3as6TZbjkfz9kP6myv/V5dnGJXHe11fG6vvwpx6n/NP31N4LNOSlWnq9WwHS/o4/a7QoX3N18yofv8yr0F6KWli3XdclnRwyNPvsqzPMOwfB5jj0hzcLl7lPOux+FjTR30cYD56KlsUK85fsmhB1QfsahSuaqJTp6udXeq4qhkvnd2ZVj3TmON39TdKPRPDu/IbpcxEP8OdT9/E8M6+8zGPFPIrndDuK52aO11XOg2Nyv4/8xvD/i4kV+O2dTDta3zjb56ZzbxNPbssXLSstGTliCVxPG0unlBeVlZaUhpfYli6v3umYMi1zNc7OzvX+n9SDjFGXg4xZ3c5xL/u6qAcYnB3OcR/3e0uh1hD3NZt+r95Kiqn1XR/73Q5RLM4wU4qhxjbXQ6xcv7q7hp3l0PcXQ6xyoHrsRnvNqqeDNRudznEv39R3C7RT35RHKmri2KnL8YcevFoe1Fsl+GY+3B+RWVa5ldUdTLnKVDmKVDmka6uyxhKBtzEqOw393uHT+iRXeExg5khS+acmejf/pghb+Hi8nh5vHhSeWFZaZFZuG1ErKzMsHTWi26XZdj6UsGaJyfZLMfaqf9zKTHs6nl128Twzs6r/w+J7sw5s1MCAA==",
+      "debug_symbols": "7Vvbbts4EP0XPfuBM5wb8yuLosjFLQwESZDLAosg/75kWlKyQ0klYidurJcglOdQnHOG4gwpPXdX64unn983Nz9uH7qzf56769vL88fN7U1sPXdAr9ce7s5vUvPh8fz+sTtDJl1165ur+K8Avqy6H5vrdXcGjl5Wb62RXLZG6a2VK8beBf5t7EFs2hg4QLaO/2NvjmY1e2HL5qJarL2r9u7FZ2sCt2X9bdUBL9SMUSMLNWPU6JFTw9hTIzJDDQJKHgkQv5MaW6gZoyZUqSGDnho/Qw0B0G9rAu5vER2Pd0B38DtA7Q5eJWQNDHtSE7zCklG+A/hgA3OsmQfpJ3oQw2lzwzJ8Q4YZfTVQ7ltDwBlrX2KHYBA5rho5aJkS9A5nrCFGcaFk+CyrWzssQeyEt6yTRrhodPQa+UWjP9NIoTyB1bs51lXLE1gDvlMjWjQ6eo14DxpFNsqy7dhmNCLrnwNkTHPmZFLM2elwQa1QaVxSnwA6nc0s+ncoi/4nrb8u+p+0/nb0+jNorz/LtP5e8y4F+V5QIH11Nhy/s9IHu8wFOwj2oSBkYafY9O7E/IUv5q8ONt1UjHf9xRPz13+qv+wGj5SquXL2Vm2wk+ZeB09HPvi4GubFkGQ4+GWVfe8q6/nYtQdX1z4N/uNLBHYk/eDVD83TiD4+aWUfoIyIaGZjAR1g2a93OPeYXGZI522R9KtJGhZJv5ik9PEFRZTReknVTZvH48nsLYdBClZPN41LZRkGuSnwL2fhyJ0VZznEBAbHL/WNkZSL57BJqftObk14Ut7WKwnzGeTjScKMtzF8SoYFNjhrSMi3fYvP3HgFmE6ZP/XlDKKFm1FueOFmlBtZuBnlRo+dm897rYds4WaUm7BwM8YNu31w02csEHyY4WbqcIFhD8MJ1EsVgkwPB0LMcUsCK8Dvy4kY/3YH/Mc7oOiKAzbYqKo6ELgsQDBYf9JM+BZbF/eb6+vNz+9b75679KeedrDPxS6r7IZjfTWehmg7xNohoRESW5As6698ic96meMB0I+/gTQN4XaItEO0HWLtkCrVhgVCtgupHxlOQ6Adgu0Q3w6hdgi3Q6rqm5W9ohC2ILUlt7yArf0eVFz8xve699e9Hbb7cNDu6/tR++seDts9HrZ7f9juaY/dm3/TPR+2ezls99VZG0r2G7zuPkfqS+k0JDRD6knzNATaIdgO8e0QaoYIt0OkHdKuvrSrL+3qa7v62q6+Yv0rmjxfUHR3vqhvh1A7pP6xopZDoPBmIqu0Q7QdYu2Q0Awx1w6BRkhs4WuyXgVK2S2Q4HYLg/pnN9MQ3w6hdgi3Q6QREls+WY58amyQ62Q0GUDTSVVs0VIkxuXglb8qkLQQj/SyXXfH5r/n95vzi+t1KrjTr083l7n+js3H/+7yL7lCv7u/vVxfPd2vU63el+kpGuPuGWH0ANJkY1ixlAL21yVbiU+/pwliurJQ5kyCx0rDhwwntyLuQyNdike/CEXy8RtyQSCsMF56ia7+Dw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -2022,125 +2119,28 @@
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
-      "verification_key": "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"
-    },
-    {
-      "name": "set_authorized",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "message_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "authorize",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "Index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "set_authorized"
-      ]
+      "verification_key": "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"
     },
     {
-      "name": "_set_authorized",
+      "name": "sync_notes",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal"
+        "aztec::macros::functions::utility"
       ],
       "abi": {
-        "parameters": [
-          {
-            "name": "approver",
-            "type": {
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "message_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "authorize",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          }
-        ],
+        "parameters": [],
         "return_type": null,
         "error_types": {
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6304245522015439386": {
-            "error_kind": "string",
-            "string": "Function _set_authorized can only be called internally"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "Index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3fThs7EMbfJddc+L/HfZXqCAGlVaQIKqBHOqp497NB2U3AkziZWaWh/m5Qt/G3nvxie8azXvv34tv97a8f18uH74/Piy9ffy9Wj3c3L8vHh+Hq9+vV4vZpuVotf1zv/vfCrP9YV94Ezz9vHtbXzy83Ty+LL9aWQleL+4dvw7+dsWm4yffl6n64MuH1qiofyIdN8UDBTaVTYQpTzG5TmCLl3cL/XC2sD6xFzji3tWinjj0WpWRHi1I2LYtMnCxytrLoGEYhvLNorQtBpotOqMucLkSbRhIx+EkVDUPCmuTHOqzdFrbJc6VpvLMtNJX1Lr6Zk9xlmZMuypxsL8ucy6JDl0WHLotOMZdlTrgsc8olmeOMP7c5cbzz4DPfmVOXzSWMni+Xsr2zI2JK+2xGm/3W/TjOZOfseGPnvD9cOIa8KRsD7RZ940fgp+FnHfip+GXw0/BzaH86fmh/Kn4e7U/HL4Gfhl8w4KfiF8FPxa+An4ZfDOCn4of5W5MfjbnqSO4jv4T4RccP8bOK3/kT1Z+OX5rKpvdF1/wK+q+OH+YfGn7eoP/q+KH9qfhZtD8dP7Q/FT+H/IuOXwA/FT/kX1T8PJ6f6/gh/6LiFzB/0/FD/kXFLyJ+ZqDgoVANJSHSZaAEQKmhICaooWQEmgwUeO8aCsElM1CQp6qhFLhkBgpcMgMFaaIKSsC7ExwUuOQaCt5y4KAgzK+h4H0EDgrGlBpKrytn4xZKSh+hdLqcLoexrMtRXnhNsNMFdacQtInG/SRsNq4i2GfHnJEgoRcrCXa6rHNOgn0mjE4imMv4ZoUl+9EXx06Xds5JsM/niHMShC9WErR9JrnmJIhoRknQwZNoCSKaURL0aINagohmtAQRzSgJBkQzWoKIZpQEO10yOydBeBItQXgSJcGENtgkWPz0/UqoCHa6onVOgjP4YkvbbbtDbBAcxo3R+FjiTmmTmdKplBHh7h7tw53XxpP7xMbPsXLyzxlPn9f4dMSiu5hmHTUO7Z+cjljudk5zjlhodlZzLouOuyw67rLoHJHhOqs58aLMOWKjzLOaE85tzl+1718KBH4aftGDn4of2p+KX0L70/FD+1Pxyw78VPwS+Gn4kQU/Fb8Ifhp+xYCfil8Avxa/A/s+p4L4RcMvG8TPOn4Z/Br8Du0bli3iFx0/xM8qfg7tT8cP7U/Fz6P96fhh/qbjV8BPww/P35T8MH9T8cPzNyU/zN9U/BKef+j4IX6uoWQklRkoiHQZKAhfayiEmICBgkCzhlLgvRkocMkVFDLIUzFQ4JIZKHDJNRQbAKWGApdcQ3FwyQwUZGlqKB5hPgMFLaWGEjCm1FBip3HKoX2zKffZfebbN5s6XZA93467RH12zBkJFvRiHcFi+vSYcxLsM4s2385CpdOlsXMS7DM/NydB+GIlQdfnLH1OgohmlAQ7XWQ8J0FEM0qCAW1QSxDRjJYgohklwU6XG89JENGMkmCCJ9EShCfREoQnURLsdDnzfLs+l06X+c5JcAZfLN0AOZHbGs9vgJzTuPFEztuNY2x2b8bPsXb3TxlvjTGf2nr6zNYfcZRfblkfzFiFDS6/q6MuTSaP3ZAMbQeDVJjCYXqsFMr2xj74jfF0duN9moyPdNj4TH7atJyKOVzY2kBxGn6jS7vF376s73OFpHdj5OC8jx9GbWtCn46vRQVthaES+3yQ762fqLhUU+kzCdGg0mlioUWlz4lai0qfCYAGldypZ25QwWjLUOl0oWyLSp8PmhtUCtpKTcWaPrfJaFDxMxzJ9tfNg2ynh243qAS0FY5K6JPK4XEl9HlUboNK7PPw1haVPg9Hb1BJfR543qLSqWduUMFoy1Dp9KjsFhUClZoKoa0wVIoDlYqKo8BRyWmsIKeP77kP02zWb5WJTcmp1pTTNfxqhYYmn67hT4IYnquOEIbkXKlVSaLicxRNVZSogqiuIKoriuqKorqSqK4k+r2yqK4s+l78lqYtFT/aN1VZoiqinsJvq3hwjAl8hrO4cZQsgdGcPi4FvhcfrscLbPNBoKHTNfyGP4cZhNPHzBAF9USeNY3t4J3j22j4mWNDI6iH7+c734fTCNob/+yroaHTNcULNKf76GiCQCOoRxALREEsEJ0VaE5vB1HkjaLIG8XM/kZDrmraxeNt/eMHFTmJij8VtKmKIhXvLy2Ncbd1pqKRHG9hcDsrQ12tCiIVSVTeiVRJogqi7xVFFvK50eFHnn7lmG2l4s95b6n29JSWKkpU/JjeVCWJqojq2tO/Ypmms8lW/m3PCaFNFUlUNklUe2ZuLZWIhisSlRcx5KO4YR44qXx0tSpLVNGKVFGkKhLVnhGgpRLRyCLyWVQXiciTiDyJyJc95NP0AosnW6uKQEX8tmEtlbUiVZaonJOo9mR8WiqJXyYviTf2bBLbVJ1c1+tw9e/N0/LmdnX/PGjWH/56uHtZPj5sLl/++zl+cvu0XK2WP65/Pj3e3X/79XR/vXq8W3+2MJs/X322V764tTXrSzf4QBfK+nLdKIa0w/ApDbUONf8P",
+      "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
+      "debug_symbols": "rZLdCoMgGIbvxWMP/P/ZrYwxrGwIYmE1GNG9z8JYrNFOOhE/fXh50HcElS2Gx92FuunA5ToC35Smd01I0zhBUETnvXvct8cAzQumC9+1Jsxj15vYgwtGDFMIbKiWvSQpo3beLtMEd7xUItNqvs+sxD9QTnhGOUefWCamGwSYnWGjqFxtuD62YVRnlAm1s+Gn2Ci22mh1bCPQ+jaCiJ2NOMNGE5JpTfkfG4UyKtHXT01pfJroTOFtrlg9hHLTuP7V2q/ytbEpbTVEO9dw08C0XrGChKbYFP0G",
       "brillig_names": [
-        "_set_authorized"
+        "sync_notes"
       ]
     }
   ],
@@ -2210,7 +2210,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "approver",
+                    "name": "on_behalf_of",
                     "type": {
                       "fields": [
                         {
@@ -2223,27 +2223,42 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
-                  },
-                  {
-                    "name": "message_hash",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
+                  }
+                ],
+                "kind": "struct",
+                "path": "AuthRegistry::is_reject_all_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "boolean"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "AuthRegistry::is_reject_all_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
                   {
-                    "name": "authorize",
+                    "name": "reject",
                     "type": {
                       "kind": "boolean"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::set_authorized_private_parameters"
+                "path": "AuthRegistry::set_reject_all_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::set_authorized_private_abi"
+          "path": "AuthRegistry::set_reject_all_abi"
         },
         {
           "fields": [
@@ -2251,6 +2266,21 @@
               "name": "parameters",
               "type": {
                 "fields": [
+                  {
+                    "name": "approver",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
                   {
                     "name": "message_hash",
                     "type": {
@@ -2265,12 +2295,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::set_authorized_parameters"
+                "path": "AuthRegistry::set_authorized_private_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::set_authorized_abi"
+          "path": "AuthRegistry::set_authorized_private_abi"
         },
         {
           "fields": [
@@ -2363,40 +2393,25 @@
               "type": {
                 "fields": [
                   {
-                    "name": "on_behalf_of",
+                    "name": "message_hash",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "kind": "field"
                     }
                   },
                   {
-                    "name": "inner_hash",
+                    "name": "authorize",
                     "type": {
-                      "kind": "field"
+                      "kind": "boolean"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::consume_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
+                "path": "AuthRegistry::set_authorized_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::consume_abi"
+          "path": "AuthRegistry::set_authorized_abi"
         },
         {
           "fields": [
@@ -2418,42 +2433,27 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
+                  },
+                  {
+                    "name": "inner_hash",
+                    "type": {
+                      "kind": "field"
+                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::is_reject_all_parameters"
+                "path": "AuthRegistry::consume_parameters"
               }
             },
             {
               "name": "return_type",
               "type": {
-                "kind": "boolean"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "AuthRegistry::is_reject_all_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "reject",
-                    "type": {
-                      "kind": "boolean"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "AuthRegistry::set_reject_all_parameters"
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::set_reject_all_abi"
+          "path": "AuthRegistry::consume_abi"
         }
       ]
     }
@@ -2461,7 +2461,7 @@
   "file_map": {
     "104": {
       "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::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"
+      "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"
     },
     "107": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
@@ -2499,9 +2499,9 @@
       "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"
     },
-    "20": {
-      "path": "std/hash/poseidon2.nr",
-      "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"
+    "208": {
+      "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.1.0/src/poseidon2.nr",
+      "source": "use std::default::Default;\nuse std::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(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::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"
     },
     "270": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
@@ -2509,7 +2509,7 @@
     },
     "288": {
       "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"
+      "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    poseidon::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 poseidon::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 = poseidon::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 = poseidon::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"
     },
     "305": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
@@ -2557,7 +2557,7 @@
     },
     "69": {
       "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"
+      "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(\n            gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n            contract_address,\n            calldata,\n        );\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(\n            gas_opts.l2_gas.unwrap_or(MAX_FIELD_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_FIELD_VALUE),\n            contract_address,\n            calldata,\n        );\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// 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(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, args)\n}\n\nunconstrained fn call_static(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, 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    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    l2_gas_allocation: Field,\n    da_gas_allocation: Field,\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"
     },
     "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",