@aztec/protocol-contracts 0.76.1 → 0.76.3

package/artifacts/FeeJuice.json

@@ -4,74 +4,23 @@
   "name": "FeeJuice",
   "functions": [
     {
-      "name": "public_dispatch",
+      "name": "sync_notes",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
-          "15238796416211288225": {
-            "error_kind": "string",
-            "string": "Balance too low"
-          },
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "3219842053230618354": {
-            "error_kind": "string",
-            "string": "Function check_balance can only be called statically"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6067862452620309358": {
-            "error_kind": "string",
-            "string": "Function balance_of_public can only be called statically"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
           }
         },
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
+        "parameters": [],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "bY/RCoMwDEX/Jc99aOoc2F+RIVWjFEortQ6G+O9LxyZu8yXkhnMvuSv01C5jY/0QZtD1Ci50JtngWa2bgDZa5+zYHM8g88Dixc+T8VnOycQE+qIEkO9Bl5Ldg3UE+lps4g9EifLD8q6qHcdsPeMr3HmF8ou/bSzvJlrTOnq/Piy+OzRJj4l+Sk0xdNQvkXK9QzOeNZZCSY7l6Cc=",
       "brillig_names": [
-        "public_dispatch"
+        "sync_notes"
       ]
     },
     {
@@ -149,11 +98,81 @@
         }
       },
       "bytecode": "JgACBAEnAAABBIBIJgAABAMmAgIEASYCAwQAHxgAAwACgEUtCIBFAAEkAAAAUSQAAABuLQQAAYBGLQQAAoBHJwIAAwSARiYCBAQCOg0AAwAEKgCAQwAAAAAAAAAAAQAAAAAAAAAAJwCARAQAAyUkAAAEAB4CAAMJJgIEAAEKOAMEBSMCAAUAAACPJAAABCksCAEDJgIFBAMAEAEFASYDAwQBACgDAgUsDAUGLA4EBgAoBgIGLA4BBiYCAQAALAgBBCYCBQQEABABBQEmAwQEAQAoBAIFLAwFBiwOAQYAKAYCBiwOAQYAKAYCBiwOAQYsDQQFACgFAgUsDgUEKgIABQAAAAAAAAAAAgAAAAAAAAAALAgBBiYCBwQFABABBwEmAwYEAQAoBgIHLAwHCCwOAQgAKAgCCCwOAQgAKAgCCCwOAQgAKAgCCCwOBQgsDQQFACgFAgUsDgUELAgBBQAAAQIBLA4EBSwNBgQAKAQCBCwOBAYsCAEEAAABAgEsDgYELAgBBgAAAQIBJgIHBAAsDgcGLAgBCAAAAQIBJgIJAQAsDgkIJgIKBAEmAgsEAiwMBwIiAAABtww4AgsMIwIADAAAAqYiAAABySwNCAIKOAIJAyMCAAMAAAHjJgIKBAA7CQEKJgICBAosCAAKLAwFCywMBAwsDAYNLAwIDgAQAAIAJAAABDssBAAALA0FAiwNBAMsDQYKLA4CBSwOAwQsDgoGJgICAQEsDgIIACgDAgQAOAQHBSwNBQIKOAIBAwo4AwkBIwIAAQAAAlAkAAAFmC4MAAIAARwMAQIAKgIAAwD/////////////////////DjgCAwQjAgAEAAACgiQAAAWqHAwBAwUcDAMCAAI4AQIDCSgAA4BDAAEsDAEDLAwCASwMAwIlIwIADAAAArMiAAAD8iYCDQQCDDgCDQ4jAgAOAAACyiQAAAW8ACgDAg0AOA0CDiwNDgwsDQYNLA0IDgo4DgkPIwIADwAAAvYmAhAEADsJARALKAANgEQADiMCAA4AAAOEIgAAAwssDQUNLA0EDiwNBg8sDQgQJgISBAMMOA8SEyMCABMAAAMyJAAABbwtBAANgAMnAIAEBAAEJAAABc4tCIAFABEAKBECEgA4Eg8TLA4MEwA4DwoMDjgPDA0jAgANAAADbyQAAAZcLA4RBSwODgQsDgwGLA4QCCIAAAPyJgINBA4sCAAOLAwFDywMBBAsDAYRLAwIEgAQAA0AJAAABDssBAAALA0FDSwNBA4sDQgPLQQADYADJwCABAQABCQAAAXOLQiABQAQACgQAhEAOBEHEiwODBIsDhAFLA4OBCwOCgYsDg8IIgAAA/IAOAIKDCwMDAIiAAABtycAgAQEeAANAAAAgASAAyMAgAMAAAQoKQEAAQX3ofOvpa3UyjsBAQIlKQEAAQVUNWDAcl0zbjsBAQIlJAAABAAmAgYEASYCBwQALAwHBSIAAARTDSgABYBEAAcjAgAHAAAEwyIAAARoLA0BBSwNAgYsDQMHLA0ECCYCCQQELAgBCiYCCwQFABABCwEmAwoEAQAoBgILJgIMBAQAKAoCDT4PAAsADSwNCgYAKAYCBiwOBgosDgUBLA4KAiwOBwMsDggEJSwNAwcMOAUHCAA4BQYHIwIACAAABN4iAAAFjywNAQgsDQIJLA0DCiwNBAsmAg0EBAw4BQ0OIwIADgAABQUkAAAFvAAoCQINADgNBQ4sDQ4MJgIOBAMMOAUODyMCAA8AAAUqJAAABbwAKAgCDgA4DgUPLA0PDQA4DA0OJgINBAQMOAUNDyMCAA8AAAVUJAAABbwtBAAJgAMnAIAEBAAFJAAABc4tCIAFAAwAKAwCDQA4DQUPLA4ODywOCAEsDgwCLA4KAywOCwQiAAAFjywMBwUiAAAEUykBAAEFAtxuJ4B2Ep07AQECJSkBAAEFWgLkG7UeqZ87AQECJSkBAAEF6J0J/qERLQ47AQECJS0BgAOABgsAgAYAAoAHIwCABwAABekiAAAF9C0AgAOABSIAAAZbLQAAAYAFAQAAAYAEAAEBAIADgASACS0AgAOACi0AgAWACwsAgAqACYAMIwCADAAABkctAYAKgAgtAoAIgAsBAIAKAAKACgEAgAsAAoALIgAABhYnAYAFBAABAwCABgACgAYiAAAGWyUpAQABBUWnynEZQeQVOwEBAiUtABjKGMo=",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "balance_of_public"
       ]
     },
+    {
+      "name": "check_balance",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public",
+        "view"
+      ],
+      "abi": {
+        "error_types": {
+          "15238796416211288225": {
+            "error_kind": "string",
+            "string": "Balance too low"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "3219842053230618354": {
+            "error_kind": "string",
+            "string": "Function check_balance can only be called statically"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          }
+        },
+        "parameters": [
+          {
+            "name": "fee_limit",
+            "type": {
+              "fields": [
+                {
+                  "name": "lo",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "hi",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::uint128::U128"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "JgACBAEnAAABBIBHJgAABAMmAgMEAiYCBAQAHxgABAADgEUtCIBFAAEtCIBGAAIkAAAASyQAAABoJwIAAQSARyYCAgQAOg0AAQACKgCAQwAAAAAAAAAAAQAAAAAAAAAAJwCARAQAAyUkAAAEph4CAAQJJgIFAAEKOAQFBiMCAAYAAACJJAAABM8eAgAEASwIAQYmAgcEAwAQAQcBJgMGBAEAKAYCBywMBwgsDgUIACgIAggsDgQIJgIEAAAsCAEHJgIIBAQAEAEIASYDBwQBACgHAggsDAgJLA4ECQAoCQIJLA4ECQAoCQIJLA4ECSwNBwgAKAgCCCwOCAcqAgAIAAAAAAAAAAACAAAAAAAAAAAsCAEJJgIKBAUAEAEKASYDCQQBACgJAgosDAoLLA4ECwAoCwILLA4ECwAoCwILLA4ECwAoCwILLA4ICywNBwgAKAgCCCwOCAcsCAEIAAABAgEsDgcILA0JBwAoBwIHLA4HCSwIAQcAAAECASwOCQcsCAEJAAABAgEmAgoEACwOCgksCAELAAABAgEmAgwBACwODAsmAg0EAiYCDgQBLAwKAyIAAAG2DDgDDQ8jAgAPAAADTCIAAAHILA0LBgo4BgwNIwIADQAAAeImAg4EADsJAQ4mAgYEDSwIAA0sDAgOLAwHDywMCRAsDAsRABAABgAkAAAE4SwEAAAsDQgGLA0HDSwNCQ4sDgYILA4NBywODgkmAgYBASwOBgsAKA0CBwA4BwoILA0IBgo4BgQHCjgHDAgjAgAIAAACTyQAAAY+LgwABgAHHAwHBgAqAgAIAP////////////////////8OOAYICSMCAAkAAAKBJAAABlAcDAcIBRwMCAYAAjgHBggJKAAIgEMABxwMBwkFHAwJCAAcDAgHBRwMAgkFHAwJCAAcDAgCBSYCCQQNLAgADSwMBw4sDAIPABAACQAkAAAGYiwEAAAsDA4IHAwGAgUcDAEHBRwMBwYAHAwGAQUmAgcEDSwIAA0sDAIOLAwBDwAQAAcAJAAABmIsBAAALAwOBgo4CAUBIwIAAQAAAysiAAADIiwMCAMiAAADNCwMBgMiAAADNAo4AwQBCjgBDAIjAgACAAADSyQAAAbDJSMCAA8AAANZIgAABJgmAhAEAgw4AxARIwIAEQAAA3AkAAAG1QAoBgIQADgQAxEsDREPLA0JECwNCxEKOBEMEiMCABIAAAOcJgITBAA7CQETCygAEIBEABEjAgARAAAEKiIAAAOxLA0IECwNBxEsDQkSLA0LEyYCFQQDDDgSFRYjAgAWAAAD2CQAAAbVLQQAEIADJwCABAQABCQAAAbnLQiABQAUACgUAhUAOBUSFiwODxYAOBIODw44Eg8QIwIAEAAABBUkAAAHdSwOFAgsDhEHLA4PCSwOEwsiAAAEmCYCEAQRLAgAESwMCBIsDAcTLAwJFCwMCxUAEAAQACQAAAThLAQAACwNCBAsDQcRLA0LEi0EABCAAycAgAQEAAQkAAAG5y0IgAUAEwAoEwIUADgUChUsDg8VLA4TCCwOEQcsDg4JLA4SCyIAAASYADgDDg8sDA8DIgAAAbYnAIAEBHgADQAAAIAEgAMjAIADAAAEzikBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFLK8tSbes5vI7AQECJSQAAASmJgIGBAEmAgcEACwMBwUiAAAE+Q0oAAWARAAHIwIABwAABWkiAAAFDiwNAQUsDQIGLA0DBywNBAgmAgkEBCwIAQomAgsEBQAQAQsBJgMKBAEAKAYCCyYCDAQEACgKAg0+DwALAA0sDQoGACgGAgYsDgYKLA4FASwOCgIsDgcDLA4IBCUsDQMHDDgFBwgAOAUGByMCAAgAAAWEIgAABjUsDQEILA0CCSwNAwosDQQLJgINBAQMOAUNDiMCAA4AAAWrJAAABtUAKAkCDQA4DQUOLA0ODCYCDgQDDDgFDg8jAgAPAAAF0CQAAAbVACgIAg4AOA4FDywNDw0AOAwNDiYCDQQEDDgFDQ8jAgAPAAAF+iQAAAbVLQQACYADJwCABAQABSQAAAbnLQiABQAMACgMAg0AOA0FDywODg8sDggBLA4MAiwOCgMsDgsEIgAABjUsDAcFIgAABPkpAQABBQLcbieAdhKdOwEBAiUpAQABBVoC5Bu1HqmfOwEBAiUkAAAEpgw4AQIEIwIABAAABrAiAAAGeQw4AgEFIwIABQAABpkiAAAGiyYCAQABLAwBBCIAAAanJgIBAAIsDAEEIgAABqcsDAQDIgAABr4mAgEAACwMAQMiAAAGviwMAwElKQEAAQXTexSaGMUAoTsBAQIlKQEAAQXonQn+oREtDjsBAQIlLQGAA4AGCwCABgACgAcjAIAHAAAHAiIAAAcNLQCAA4AFIgAAB3QtAAABgAUBAAABgAQAAQEAgAOABIAJLQCAA4AKLQCABYALCwCACoAJgAwjAIAMAAAHYC0BgAqACC0CgAiACwEAgAoAAoAKAQCACwACgAsiAAAHLycBgAUEAAEDAIAGAAKABiIAAAd0JSkBAAEFRafKcRlB5BU7AQECJS0AGMoYyg==",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "check_balance"
+      ]
+    },
     {
       "name": "initialize",
       "is_unconstrained": false,
@@ -1798,7 +1817,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7VjbTuMwFPyXPOfB52afw6+sVqhAQZWqFpWy0grx72sX7ABNWtXtAhV5qep0pp5Mxp4kT83N9Orx7nK2uF0+NBe/npr58nqyni0XcfTUAG2OPdxPFmn4sJ6s1s0FeI9tM13cpK8Bn9vmdjafNheentstMKIPr2BEtQI23wc21lcwOYTdYPBkWnQwdHD01ouXDh5Ch9befydPGc3g3qF/tw3w6MyAMzI6M+CM/9bOMEnnDNseZxDQZyXAcqQzYXRmwBk92hl2lsEMqAWsbjOB/ecJ0PVOAMZ5AvSyewK1MoE56NQEOuv9AOFbO/OFqUccnRlwho52xhx2zojsdobKrsrABQqkGzF8AjE+e2ngdLcYMCHLf20i/u1W01cJMQSlE2x7Z5Lzlu8/Vz460BJkRwYf9fSXeDyLrIeA9i1aLdEEDLv9UZfVKL/dt1+i2d+bhGXlEu+pNWPvshjhPRcrFmZWA4HkzUp5Wbb9LcuuyGHRH7mhkRudGXAGRmcGnMGjnTldCRKdQMzXtQjxecuXz5W/uwTj4Go1m89nd5fv3qO59MG9TgvkpIvgx2yxHE7xh1PC4RQ9kBJHkJD9d/ZStqkg9r474wgTMvQSTcvjmHNbNwGBKjhcwZEKjq/ghAqOVnDscI66Cg5UcCpyoBU50IocaEUOtCIHWpEDrciBVuTA+nPQ3R07x1scqOBgBYcqOFzBkQqOP5QTR5SgAy/clctzYLzD2dpUeaykOPwzWc0mV/Npaun06+PiOpd2HK7/3udfcq3fr5bX05vH1TQVfNftKVgELUMUAmkFiGtFSuttDsVHT3KlzxJDrPWWGfE9JDjqrmo6BqFFLFdraJLneC7/AA==",
+      "debug_symbols": "7VjtbuIwEHyX/M4P75e921c5nSra0goJQUXpSaeq7342VzulJCAM1xZd/iA2zODJZLPj5KW5m948P1zPFvfLp+bqx0szX95O1rPlIlYvDdDm2NPjZJHKp/VktW6uwHtsm+niLn0N+No297P5tLny9NrugBF9eAMjqhWw+T6wsb6BySHsB4Mn06KDoYOj1168dPAQOrRKH5o8ZTSD20L/bBvg0ZkBZ2R0ZsAZ/62dYZLOGbYDziCgz0qA5URnwujMgDN6sjPsLIMZUAtYYbOA/eMF0PUuAMZ5AfSyfwG1soA56NQEvuh5gPCtnfnCrkccnRlwhk52xhx2zojsd4bKVGXgAgWyjRg+gxifvTRwul8MmJDlvzYR/37U9EVCbIKSCbY7meSy5fvPlY8OtDSyI4OPevpDPJ5F1kNAh25aLa0JGPb7oy6rUX4/t8NGTH9uEpY7l/hArBl7l8UIH7hYMTCzGggk7+6Uv3L6U5ZdkcOi/+VAIzc6M+AMjM4MOIMnO3O+ECQ6g5ivSxHiy5Yvnyt/fwjG4mY1m89nD9db79Fc+uBepwVyp4vgx95iOZ7ij6eE4yl6JCVWkJD9O3spYyqIbWdnrDAhQy/RtDyOObezCQhUweEKjlRwfAUnVHC0gmPHc9RVcKCCU9EHWtEHWtEHWtEHWtEHWtEHWtEHWtEH1t8H3e7YOd7hQAUHKzhUweEKjlRw/LGcWFGCDrxwVy7PgXGHszNUeYykWP6arGaTm/k0pXT69Xlxm0M7luvfj/mXHOuPq+Xt9O55NU0B32V7aiyCliEKgXQHiGtFSuptDsVHT3IlzxJDrPWWGfE9JDjqrmo6BqFFLFdraJHXeC5/AA==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "enqueue_public_function_call_internal",
@@ -1809,37 +1828,94 @@
       "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAABr/eb5gz7ptC9MpFVojS7n+kd8rwVZpXOcis7SCicafLNZYze6tsw5Nf9/WnBX4cmUmJZPm9sEQLJ3f8DxkKz0mKhBdX7PyOo1ofY4Wc1rOqL9VrzvEMI/ZzVrqMuDx7RSdsdmKHZRiFa9XVT+4c2bWIIGEtZe3IxmP0m4+fCaoFlAUx0ZgBQl1TSe8mwBCcWxusofAJoJEsKwQyh+cdkIVuYNKfKHPmg68YwQ40Qt3WSRv5VN0tq6ovfVN5b2tDQo+oGAnqwZYja6BPv3+NWeyYSLFx1Jx4uUqU8T3g1jFLQ8GMy+qPOdREopI2CYi13kRdOIaPEWr3wF6MBtZQG8ZQQ+yGLs8y+0Z4B+4kpDy1WWQDFLAsBJN/nyOxC/c4SkEzpDx13b0bdz4c2zeX9oEo8kQNiaGbqX+EMND/HNHEgyY/Q8Tsfu5HvNDyZpbnqsm1/IWqpKnQar6SLVPJeQkd8FJ3J1AbHeUiM9c5PTN19RC3uArXdoLZZUUpk3Y/ARWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQpjDMR/JFw+S3pQLBCqrmQ1TxqOyYznNprc9+SCDFBWQewX0CKYShHJZAWuSBK5L83U36xlrBcHZj6UQFqm6y7B9JCsKqWzJUZPLbrj2ppNLBTZUN4QSet3bDZor0fImITIfgXgElQyoTM4/pZfzeRS1r52UR5nk2w7nbcRMHEhxQHuXHUZSUuien7WhICd8GF6pmJPVoWfU6cq9qKeg+XKvmMef9SA+ZAwA4tIS1vkplPVZg44AbUU15W/rgR1wEAph3qx2s3DKT0L3OmZct1qevcWM1L34r35/z/o21bcS5ZeJ8Nnbs/Fa3lOEt4SQ2x2DN5xzvkESPev8iMn8jWK3KtwTdDjKDTNxRFpXqWkOZE9YS6+kVBJM8BrVvgsTkBGeJB7rvr/1x9fyDcbFrRtq943CBtf3eFPwX95+vTci9GhEmm+V0TvIFE7Yj++pOZGnX1x/Ov+OzMJuDxJlWvDYBoM7s5aQd1z3BVHQ6nyEcuDvMvg6agFayHtr99BEcEBGhQ8j0QTh90W+MjDtqaPc/6h+jMh6rQPFwP/rdy/gjO2MGb6Sg26zTRxI04TlJgx8awUtVw01cgtVMokF22F49/P67iM5fqk21/jFZ6QDOY4m/RAw5m9opTGS9PJEks1LB+hsRk059NsnAkuA7thX0qWo9ZbykKXK64HytX7QKeiCA+DkFjbFFwigIGlOeGoiqMNVDSkZRt1DlICYr/I3xXPjP8RON0KW3b6RW08obtRH30Bqa/oOPRCTkw1G4eSXO6KcGtGSMvigaFqZFP5OXQ8hTztLxmnzMqjaAe3i6YKIVNCaARiIwAinIzeOrdo6yOziFhlfLA9Qva2SdBLWGysisZHDomywUefA0q/31y4S7kc4W3jO71zk971I0NAaWKh06ebqsrlSNooCuPd25LrvXZChoahHSpzsuzZAbNCGxfIAZY/leSv0z9QEA/2EVtUzDkl+k0Ix3swhX+DG/VtgxwBIu7diaX0DLzqn8/VCBg3sfnV4OPIgRUrAUY5oCs1nEvc5D9SDVzgWsCHIsGz9NHb3GInvIeaeQgNB1+l1xIk2dXOmFlhOP4wjvnA7dPl5P4Tb8YTEZRsA14HycTa23Upgu6+MtKrTdADvLWaXoXf/3T+oALv4D3ZLIiCkdy7zfqCOBLIhBI6iXfui9n1tHtSNj4JRIYF2iRDC2REwLFrsGzRSYiE4xLloSkBAin41HPiI8GoLzZ1C0WAPJz9VjgaWyJ37gwhPAzIZs8W+g7TLKCIlkGhqaSmX4K3InEjXW1cWNvW760qAb29FliAjAbauTrDrvq3SAzQAZvKBNXSPEZYxw/4H+p1wADTj4nRU75krS/hLl7qnRxLiV4NVHfUMAE7HzR9N2LO2SmbyrEl5tl5WVoxaMbFO0Y92zwzuzLR5jedBrom2ToJY+ER3wbYlZaVZunuziDLi0pn7aGeNAVC8xbFtyCUjU9Q/pw6ZI5wcHGficaDurFFdOsWhmau3STOk78mMWbKBTt580n2u0AwzwShgvEsEYtONbUuh5HY6dOzbEcofNGloDCcOVRUVNEWS9ZGI+nZRLbOeiSgmsyYQ7gglHgBfzpF8DV3KAZR3xS9gdTMrYSAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgbNtolMQSk+pHYpU07a4yPsi4MdQfqE3r0hQF6UENXbC/4bCZ6Cji6WjqVRp3SNx9a8FNbxNfW7qIcetH6+dBAPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
     },
     {
-      "name": "set_portal",
+      "name": "process_log",
       "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
           },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
-          },
-          "2236649814169388962": {
-            "error_kind": "string",
-            "string": "PublicImmutable already initialized"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
           }
         },
         "parameters": [
           {
-            "name": "portal_address",
+            "name": "log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "recipient",
             "type": {
               "fields": [
                 {
@@ -1850,32 +1926,27 @@
                 }
               ],
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgIEASYCAwQAHxgAAwACgEQtCIBEAAEkAAAARSQAAABNJwIAAQSARSYCAgQAOg0AAQACJwCAQwQAAyUkAAADTSYCAgACLgwAAgADHAwDBAArAgAFAAAAAAAAAAAAAAAAAP//////////////////////////DjgEBQYjAgAGAAAAmSQAAAN2JgIEAAAKOAMEBSMCAAUAAAC0JgIGBAA7CQEGKAIAAwA7msoCLgwAAwAFCjgFBAYjAgAGAAAA1SQAAAOIJwIABQDerS8MAAUAAywIAQMmAgUEBAAQAQUBJgMDBAEAKAMCBSwMBQYsDgQGACgGAgYsDgQGACgGAgYsDgQGLA0DBQAoBQIFLA4FAyoCAAUAAAAAAAAAAAEAAAAAAAAAACwIAQYmAgcEBQAQAQcBJgMGBAEAKAYCBywMBwgsDgQIACgIAggsDgQIACgIAggsDgQIACgIAggsDgUILA0DBAAoBAIELA4EAywIAQQAAAECASwOAwQsDQYDACgDAgMsDgMGLAgBAwAAAQIBLA4GAywIAQUAAAECASYCBgQALA4GBSwIAQcAAAECASYCCAEALA4IBywNBQksDQcKCjgKCAsjAgALAAAB5yYCDAQAOwkBDAsoAAmAQwAKJgIJBAEjAgAKAAACeiIAAAIBLA0ECiwNAwssDQUMLA0HDSYCDwQDDDgMDxAjAgAQAAACKCQAAAOaLQQACoADJwCABAQABCQAAAOsLQiABQAOACgOAg8AOA8MECwOARAAOAwJCg44DAoPIwIADwAAAmUkAAAEOiwODgQsDgsDLA4KBSwODQciAAAC6CYCCgQLLAgACywMBAwsDAMNLAwFDiwMBw8AEAAKACQAAARMLAQAACwNBAosDQMLLA0HDC0EAAqAAycAgAQEAAQkAAADrC0IgAUADQAoDQIOADgOBg8sDgEPLA4NBCwOCwMsDgkFLA4MByIAAALoLA0HCQo4CQgKIwIACgAAAwImAgsEADsJAQsmAggECSwIAAksDAQKLAwDCywMBQwsDAcNABAACAAkAAAETCwEAAAsDQMEACgEAgUAOAUGBywNBwMvDAABAAImAgEAAy8MAAMAASUnAIAEBHgADQAAAIAEgAMjAIADAAADdSkBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFWgLkG7UeqZ87AQECJSkBAAEFHwotJ9yCh6I7AQECJSkBAAEF6J0J/qERLQ47AQECJS0BgAOABgsAgAYAAoAHIwCABwAAA8ciAAAD0i0AgAOABSIAAAQ5LQAAAYAFAQAAAYAEAAEBAIADgASACS0AgAOACi0AgAWACwsAgAqACYAMIwCADAAABCUtAYAKgAgtAoAIgAsBAIAKAAKACgEAgAsAAoALIgAAA/QnAYAFBAABAwCABgACgAYiAAAEOSUpAQABBUWnynEZQeQVOwEBAiUkAAADTSYCBgQBJgIHBAAsDAcFIgAABGQNKAAFgEMAByMCAAcAAATUIgAABHksDQEFLA0CBiwNAwcsDQQIJgIJBAQsCAEKJgILBAUAEAELASYDCgQBACgGAgsmAgwEBAAoCgINPg8ACwANLA0KBgAoBgIGLA4GCiwOBQEsDgoCLA4HAywOCAQlLA0DBww4BQcIADgFBgcjAgAIAAAE7yIAAAWgLA0BCCwNAgksDQMKLA0ECyYCDQQEDDgFDQ4jAgAOAAAFFiQAAAOaACgJAg0AOA0FDiwNDgwmAg4EAww4BQ4PIwIADwAABTskAAADmgAoCAIOADgOBQ8sDQ8NADgMDQ4mAg0EBAw4BQ0PIwIADwAABWUkAAADmi0EAAmAAycAgAQEAAUkAAADrC0IgAUADAAoDAINADgNBQ8sDg4PLA4IASwODAIsDgoDLA4LBCIAAAWgLAwHBSIAAARkLQAYyhjK",
-      "debug_symbols": "7Z3bbuM4DIbfJde5EKnzvMpgUfQ0RYAgKdJ2gUXRd18nqB1vwsaxqOkOoP+miBtStD7TIkXZyvvi4fHu7elmtfm1fVn8+Pm+WG/vb19X20139P6xXNztVuv16ulm/O+F2f9JfJB/eb7d7A9fXm93r4sfFKNfLh43D93HZLhr4ddq/bj4EezH8kzYesefwjYYPwhTYEGaOA1N27F0ltqONtlP6eiMG6QTScKU+hOJzHRZmMjYvunucwhj8b+WixQBRgST7R8OJh7BUL7c13w8aWPMIMtebJlz33DgCVkid2QY0oS0H07Z5zzq3wF3Au5vxE3Wg/d38nYGvL+VN8aTb+Xtp8MluTHvg1IqUAolliKVKIUCpSTf6ImPSj5ddjzOHD+FOXuecLz/L0WilNvpa/YV+ppNP6CYkwGlM8HG/H4T6bebIKs2YbvBqDdB2U05RbKhv87jpmWnCPY4PmYz5RQ0hIDuc7InTsFsGupr0PeVY39ClscxRI6oxpkh7o1imRxRk+OeTHLxyJFDFmN7L+x4FFGD5O/dVelHKCa+LOyHk/Acx6J7gtaAoJKgB0EdQQcf1BKEDyoJeviglqADQSXBBII6gsGCoJJgBEEdwcggqCSIWd0VBEN/yj7QKcGEbEZLEBm1lmAGwWmCg2z4r2hH0BLuYi1BB4JKgriLlQQZPqglCB9UErTwQS1B1GaUBB3mxVqCqM0oCXoCQSVB1GaUBANmdVqCqM1oCSKjPiW4xxKxfCRiQe4rYUlIaEUsyBAkLBmpp4gFsVzEggAtYHHGAYuEBQFawkII0CIWlJEkLIwALWJBgJaw4L0JGQu8RcSCdE7C4lBvEbEgnZOweHiLiKXVdI5z/24ojzc3EIXJUD6eczplGFrN/WoybDX0z2JIozf6/ekzsy62mlXWZNhq9KzIMLUaamsyRFy+hmEYcFA6jSme4IdXMHRmOGdn6Iwh/FDNsNnaYE2GyA/1DFutI81i6HmIy96bU4bNPgtfkyH8UM2w2ae5KzL0ra7w1mSI+bKaIWpfeoaofVVg2OqzlxUZJsz19Azhh2qGGePhNQzjsEGsz3zGEHFZyzAY+KGeIXJsNUOsBVRgiJqDmiHWAiowRFxWM0Qd+xqGlgaG1tIZQ9Sx1QybfYi3JkPEZTXDZvd2qckQcVnPEDFFzTA4MFQzhB+qGTa7IUxNhsht1AyxJlWBIXKbaxi6ODAMp2tSodlNbGoyxFqAlmE0iMt6hsgP1Qyb/X2Bmgzhh2qGjPFQ+25FZMxT1Awt8kM9Q8xT1Axdq3E5Dls0cLS2WPjAsNV5yhyGFMLwDGdIZ37Y7JY1FRk2uzdLTYatPo9dkWGz76fMYhhj3zDF7M8Ytprb1GTY6ny5IsNm97epybDV+XJFhs2up9RkiJiiZZiafcenJkP4oZ4hchs1w2bfk5rFMB+fFcl8zhC1LzXDZtekajKskWMPu1Ra9lMMu5lR39E4bnpfDjkXDrbvaQzZXBYmIjd0lSjZsfi+r9Y21NfUTF+J2EmdjUcb7nTtoWtSTKbyYCl7f66T5+vIBfoJnThf54si9sUdtTutUKL1RaFySsuXaKUiW6nIVi6ylUtssTFFWiXXi6nIFhX164uHbSa0vgjlU1qxRMtSkVaYPcawE7ln0//YQmZBZ/64xMHOtxPifJ1IBTq+QGf+OMvJFegU2Mnzx2ZruECnwA4V2CHRr7Pv/TpHPtORNyiY0CmwI7+APqGT5+u4AjuuwM5kLiDppPnXNNgCnQI78mZwl3XkF00mdAruhewKdOaPB87MH6+dHI8ndErsFPSHbYHO/Ovj7Ew/+OiO/r7drW7v1o8vncb+y7fN/etqu/k8fP3nuf/mbrdar1dPN8+77f3jw9vu8Wa9vd9/tzCff352Na4l5bQ/l8Nh4CWFeEjoDodp2aW5ndXO8r8=",
+      "bytecode": "H4sIAAAAAAAA/92c927bMBDG5URKIieOndG9927leHeme+/W/dsdfosWAtqHSPu09Zfw7DPDAilCovkqQJCto+9+PFHUiTy6EG1s3cFeMJ9jc5w2R5xfjMY3Kbtqjtn2tqpHXVkoxgIB4wQB4yQBY0zAmBAwThEwThMwzhAwpgSMRQLGWQLGOQLGEgHjPAFjmYCxQsC4EIAxBOciCeeSR04d24fiXY52fhvdRcC4m4BxDwHjXgLGfQSM+wkYDxAwHiRgPETAeJiA8QgB41ECxmMEjMcJGE8QMJ4kYDxFwHiagPEMAeNZAsZzBIznCRgvEDBeJGC8RMB4mYDxCgFjRsBYJWBcIWCsETDWCRgbBIxNAsYWAWObgLFDwHiVgPEaAeN1AsYbBIw3CRhvETCuEjDeJmC8Q8B4l4DxHgHjfQLGBwSMDwkYHxEwPiZgfELA+JSA8RkB43MCxhcEjC8JGF8RML4mYHxDwPg2AGMIzncknO9JOLuBOKMPFvTEYMfCLSyMwsIjLOzBwhksTMHCDyyswMIFLAxA4j0S25E4XhnsSHxGUjESdpEEiyRTJHEiSRJJiEjyQxIdktSQBIYkKyQxIUno6GA/NtiRRIIkDSRBIMkAk/iYJMckNCZ5MYmKSUpMAmKSDZNYmCRCrTDJgUkEDNJjEByDzBjExSApBiExyIdBNAxSYRAIgywYxJBBArzk4iUSL2l4CcJLBoJ4BMkIQhHkIYhCkIIgAA9ZPMTwkEAnjE4OnQhuUtwAaFzd6M+bNJIf5pia44SSe1xEV00tuz71t7POx9RRP4/8tdTonAmiv9ES/WkY/kwW2t7LR/p1XcTupDl285Evu/k4k5RZU2XWrDJSnzDXu14P66/qSsnyUaTqIraLYWzXCpY9fV20TOwXo5Btc2NRsrYnPLZ/pO8oSZl8xFOwZHG+uR4iS5RMri/snFfl7LY1Y8mEBZu035LyjWwfjEyuaax0+muvjXbY9lrP/l17rVf/x/YaW7I431yPv22vum3Z7TWJRpv0pSKbUrKflmxayX7lI9sNxdE0n8P2yRvPYH3v+X6GLTn4tS1s0/nIH9IGJ9W5RPlv3T+6vCVLlSzOx+0UzfdY2dG6hCOxytfN97I5TqnfyO8rDvtTlv0xbsc52y+po3zqKI+2dsl8njU72tA3+U20+d7Fvmq+Z9vamh1XP+lPf6vm6gs98n8R/bNB9NeH+ufC8A/jqlIY/w/1z4fh74v+chj9TdFfCaO/IfoXguhfGcYJ+s927DhhSZ33GNduOU4Q+0WLNVScsGTx2P7RcQJkyw7WikNm9wHLDjvLDjsuXfMedS141FXcoXUsedRV8agr9ajL53Wc86jLp7/KHnXNeNTls9379Jdcx7DjVVnmitOiAPqLYfQP+37po/W7ma6T2E+s8l8tP88F8fNoHEr6M+0LVyzl0/ZWn9div+TgEe6iQ7adP0D70mj3O+1GZxDSV5srnaxg6RdW+5x+L9L9iy7veva74j6Pvs5cYxBl5VdssZLNW7JEyYRRj0G44mKf/Fvxv7Zfccjs/nmr13IxGm9r+n6cjUb3c5z7r3urvfHHLuuMRn8SjY8xRpb9xCr/3Xy3+7rt3iP9Vq/ar/X6vUbv8+f6p96ipV/7EH76DXVGL3ipUwAA",
+      "debug_symbols": "tZbLCoMwEEX/ZdZZOGPV1l8ppUSNJRCiRC0U8d8bpQ9p13cTmDA5kyxOuDM1pppuV+vbbqDyPJPraj3azsdqXhRVwTpnb9f9NiXrwolsB4Ze+7UeRh1GKg+iyPiGyiyJx1vrDJV5uqi/xuLdWBSfxkyWi4rkFEY+wMgZjJzDyAWMfISRTygyJzAyw8gwBxnmIMMcZJiDDHOQYQ4yzEGGOSgwBwXmoMAcFJiDgnFwidVdB6srZ14Bop18vcsT46M3P9GiD11tmimYNWR888X69nihTLZfPxYsueKU45A46Ak=",
       "brillig_names": [
-        "set_portal"
+        "process_log"
       ]
     },
     {
-      "name": "_increase_public_balance",
+      "name": "set_portal",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "internal"
+        "public"
       ],
       "abi": {
         "error_types": {
-          "10502589790419500451": {
-            "error_kind": "string",
-            "string": "Function _increase_public_balance can only be called internally"
-          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -1884,9 +1955,9 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "206160798890201757": {
+          "2236649814169388962": {
             "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+            "string": "PublicImmutable already initialized"
           },
           "5019202896831570965": {
             "error_kind": "string",
@@ -1899,7 +1970,7 @@
         },
         "parameters": [
           {
-            "name": "to",
+            "name": "portal_address",
             "type": {
               "fields": [
                 {
@@ -1910,129 +1981,17 @@
                 }
               ],
               "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "amount",
-            "type": {
-              "fields": [
-                {
-                  "name": "lo",
-                  "type": {
-                    "kind": "field"
-                  }
-                },
-                {
-                  "name": "hi",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::uint128::U128"
+              "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "_increase_public_balance"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "packed_note_content",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/9VZy67aQAwdSEJIuAEKn3Cl7tomXJ47Fn3c30AFPqHrrLppP7qMGCcH46siYVfFEpoknhyfOXZmJqHjztY//TrhOA5tz10b9dmGtrzPKkWs0pJn50F4dh+EZ/QgPGNFnh2Bp2/peUvc+ZlL3fl5bC7iTT7BEdzk/gYAwX6HNgttF/yKCakyYZBa+Otyvs/cpSnzf8kCZmqDvyD8vg1+Sbw/1y0+joXiRqF9rVstX+Eeb0U4xuIlXPJ1wfeF+SLwfWU+rOFvzId1T5xIN1qYlOtqY50XGlsKY+u80TrXaofXSOvcmdZoRTnPGB/On/gU1Kdu+fSYLwZfxnwJ+Eh/3z5DP577FPp9hONP0IfXZ+Su65n8lH/U3aK+YgP8k82lHPD8xPVlbPRhDmLQ85npY7FuoD4W+nt9pm/wp2Nvae0ai5ieqBFp1sf+zJeBL64v4+ThPIY4iEU8Etb/QzgfhbYH99D9YyF+j8W/4C1cQ404ViRco/7++Xwfjgfh52voJ93jructvc31ci7N4Xr4qwY/s+F/JPzcBn9J+AMb/GZv82SCPysJv7Dh38xBQ5v6afaWIxv+B8Ifm+DPD7QOv3OtNXNEOJ7Adb35u6pu2SNh/JxxtdojTRgfrg+uwd43FbiOBR/P4VSIMxXiSFiZItaTItboPx1jXxFroIg1VMTSzGOqiKWpV66IVShiada9pl6UR2mf5m0b2vJOk/ZpiviVtE/TfJcnram+YkFDHF/C+v9gOg9MeFYzWnPoWacYGLswin3rek3xC4EP8c4F3z0fZw+L9XGzXmxOW7JqOds0+SwYV34N34twPsb+0tov7fsUtS6ld/8h6OotBl/BfAn4iKP07j804n+L/hh/LPj4+n9rLifuej0csHHjN6+typjb74HSt3rj+Wtx67NJ8XN3PV//q++NqA/fS+cC17Hg4/uTXIiTC3EeEYt/s0cNfV2TTnHd+rVyuVq3f3TRXJS4y/8BHIufsP6/wjmOjdp75vzjalcdX3bH3WK338+/7yYM31sXdPoDg5oBSR0fAAA=",
-      "debug_symbols": "tdfNaoQwFIbhe8k6i5z8mIm3UsoQNQ6BECVqoYj33jhM26GzLN9GiBwfN77g2dkQuu12jXmcFta+7SxNvV/jlOtpPzjrSkwp3q7Pt5k4L87c55fZ5/O4rL6srNWSs5AH1hpRnx5jCqxt1MFfBu33oLU/g0Ye75y5BgVbFHxBwQ4EkxAwmWCyhMkKJmuYbGByA5MtTL7AZFiDBGuQYA0SrEGCNUiwBgnWIMEaJFiD9L8GnXoM1k/hhXYwWgocTTha4miFozWONji6wdEWR+NqlLgaFa5GBarxqKcPX6LvUnhsTeOW+6clav2cw599ai5TH4athHOz+l2qzvSU4drc/zzqgZTmpFx9SX3RFw==",
+      "bytecode": "JgACBAEnAAABBIBFJgAABAMmAgIEASYCAwQAHxgAAwACgEQtCIBEAAEkAAAARSQAAABNJwIAAQSARSYCAgQAOg0AAQACJwCAQwQAAyUkAAADTSYCAgACLgwAAgADHAwDBAArAgAFAAAAAAAAAAAAAAAAAP//////////////////////////DjgEBQYjAgAGAAAAmSQAAAN2JgIEAAAKOAMEBSMCAAUAAAC0JgIGBAA7CQEGKAIAAwA7msoCLgwAAwAFCjgFBAYjAgAGAAAA1SQAAAOIJwIABQDerS8MAAUAAywIAQMmAgUEBAAQAQUBJgMDBAEAKAMCBSwMBQYsDgQGACgGAgYsDgQGACgGAgYsDgQGLA0DBQAoBQIFLA4FAyoCAAUAAAAAAAAAAAEAAAAAAAAAACwIAQYmAgcEBQAQAQcBJgMGBAEAKAYCBywMBwgsDgQIACgIAggsDgQIACgIAggsDgQIACgIAggsDgUILA0DBAAoBAIELA4EAywIAQQAAAECASwOAwQsDQYDACgDAgMsDgMGLAgBAwAAAQIBLA4GAywIAQUAAAECASYCBgQALA4GBSwIAQcAAAECASYCCAEALA4IBywNBQksDQcKCjgKCAsjAgALAAAB5yYCDAQAOwkBDAsoAAmAQwAKJgIJBAEjAgAKAAACeiIAAAIBLA0ECiwNAwssDQUMLA0HDSYCDwQDDDgMDxAjAgAQAAACKCQAAAOaLQQACoADJwCABAQABCQAAAOsLQiABQAOACgOAg8AOA8MECwOARAAOAwJCg44DAoPIwIADwAAAmUkAAAEOiwODgQsDgsDLA4KBSwODQciAAAC6CYCCgQLLAgACywMBAwsDAMNLAwFDiwMBw8AEAAKACQAAARMLAQAACwNBAosDQMLLA0HDC0EAAqAAycAgAQEAAQkAAADrC0IgAUADQAoDQIOADgOBg8sDgEPLA4NBCwOCwMsDgkFLA4MByIAAALoLA0HCQo4CQgKIwIACgAAAwImAgsEADsJAQsmAggECSwIAAksDAQKLAwDCywMBQwsDAcNABAACAAkAAAETCwEAAAsDQMEACgEAgUAOAUGBywNBwMvDAABAAImAgEAAy8MAAMAASUnAIAEBHgADQAAAIAEgAMjAIADAAADdSkBAAEF96Hzr6Wt1Mo7AQECJSkBAAEFWgLkG7UeqZ87AQECJSkBAAEFHwotJ9yCh6I7AQECJSkBAAEF6J0J/qERLQ47AQECJS0BgAOABgsAgAYAAoAHIwCABwAAA8ciAAAD0i0AgAOABSIAAAQ5LQAAAYAFAQAAAYAEAAEBAIADgASACS0AgAOACi0AgAWACwsAgAqACYAMIwCADAAABCUtAYAKgAgtAoAIgAsBAIAKAAKACgEAgAsAAoALIgAAA/QnAYAFBAABAwCABgACgAYiAAAEOSUpAQABBUWnynEZQeQVOwEBAiUkAAADTSYCBgQBJgIHBAAsDAcFIgAABGQNKAAFgEMAByMCAAcAAATUIgAABHksDQEFLA0CBiwNAwcsDQQIJgIJBAQsCAEKJgILBAUAEAELASYDCgQBACgGAgsmAgwEBAAoCgINPg8ACwANLA0KBgAoBgIGLA4GCiwOBQEsDgoCLA4HAywOCAQlLA0DBww4BQcIADgFBgcjAgAIAAAE7yIAAAWgLA0BCCwNAgksDQMKLA0ECyYCDQQEDDgFDQ4jAgAOAAAFFiQAAAOaACgJAg0AOA0FDiwNDgwmAg4EAww4BQ4PIwIADwAABTskAAADmgAoCAIOADgOBQ8sDQ8NADgMDQ4mAg0EBAw4BQ0PIwIADwAABWUkAAADmi0EAAmAAycAgAQEAAUkAAADrC0IgAUADAAoDAINADgNBQ8sDg4PLA4IASwODAIsDgoDLA4LBCIAAAWgLAwHBSIAAARkLQAYyhjK",
+      "debug_symbols": "7Z3bbuM4DIbfJde5EKnzvMpgUfQ0RYAgKdJ2gUXRd18nqB1vwsaxqOkOoP+miBvStD7TIkVZyvvi4fHu7elmtfm1fVn8+Pm+WG/vb19X20139P6xXNztVuv16ulm/O+F2f9JfJB/eb7d7A9fXm93r4sfFKNfLh43D93HZLg7w6/V+nHxI9iP5Zmw9Y4/hW0wfhCmQII0cRpObcfSmQXpaJP9lI7OuEE6icKU+guJzHRZmMjY/tTd5xDG4n8tFykCjAgm2z8cTDyCoXy5rfl40caYQZa9eGbO/YkDT8gSuSPDkCak/XDJPudR+w64E3B/I26yHry/k7cz4P2tvNGffCtvPx0uyY15H5RSgVIosRSpRCkUKCX5QU98VPLpsuNx5vgpzNnzhOP9fykSpdxOW7Ov0NZs+g7FnHQonQk25vebSL/dBFm1Cdt1Rr0Jym7KKZIN/X0en1p2imCP/WM2U05BQwjoPid74hTMpqG2Bn1bOfYXZHkcQ+SIapwZ4t4olskRNTnuySQXjxx5H9eE2N4LOx5F1CD5e3dX+h6KiS8L++EiPMex6J6gNSCoJOhBUEfQwQe1BOGDSoIePqgl6EBQSTCBoI5gsCCoJBhBUEcwMggqCWJUdwXB0F+yD3RKMCGb0RJERq0lmEFwmuAgG/4r2hG0hKdYS9CBoJIgnmIlQYYPagnCB5UELXxQSxC1GSVBh3GxliBqM0qCnkBQSRC1GSXBgFGdliBqM1qCyKhPCe6xREwfiViQ+0pYEhJaEQsyBAlLRuopYkEsF7EgQAtYnHHAImFBgJawEAK0iAVlJAkLI0CLWBCgJSxYNyFjgbeIWJDOSVgc6i0iFqRzEhYPbxGxtJrOce7XhvJ4cwNRmAzl4zWnU4ah1dyvJsNWQ/8shjRa0e9P35l1sdWssibDVqNnRYap1VBbkyHi8jUMw4CD0mlM8QQ/vIKhM8M1O0NnDOGHaobN1gZrMkR+qGfYah1pFkPPQ1z23pwybPZd+JoM4Ydqhs2+zV2RoW91hrcmQ4yX1QxR+9IzRO2rAsNW372syDBhrKdnCD9UM8zoD69hGIcNYn3mM4aIy1qGwcAP9QyRY6sZYi6gAkPUHNQMMRdQgSHispoh6tjXMLQ0MLSWzhiijq1m2OxLvDUZIi6rGTa7t0tNhojLeoaIKWqGwYGhmiH8UM2w2Q1hajJEbqNmiDmpCgyR21zD0MWBYTidkwrNbmJTkyHmArQMo0Fc1jNEfqhm2OzvC9RkCD9UM2T0h9q1FZExTlEztMgP9QwxTlEzdK3G5Ths0cDR2mLhA8NWxylzGFIIwzucXZXmlGGzW9ZUZNjs3iw1Gbb6PnZFhs2uT5nFMMb+xBSzP2PYam5Tk2Gr4+WKDJvd36Ymw1bHyxUZNjufUpMhYoqWYWp2jU9NhvBDPUPkNmqGza6TmsUwH98VyXzOELUvNcNm56RqMqyRYw+7VFr2Uwy7kVHf0Dg+dZIQxmD7lsaQzWVhInJDU4mSHYvv22ptQ21NzbSViJ3U2Hi04U7nHrpTislUHixl78918nwduUA/oRPn63xRxL64o3anFUq0vihUTmn5Eq1UZCsV2cpFtnKJLTamSKvkfjEV2aKidn3xss2E1hehfEorlmhZKtIKs/sYdiL3bPofW8gs6MzvlzjY+XZCnK8TqUDHF+jM72c5uQKdAjt5ft9sDRfoFNihAjsk+nX2vV/nyGc68gYFEzoFduQF6BM6eb6OK7DjCuxM5gKSTpp/T4Mt0CmwI28Gd1lHXmgyoVPwLGRXoDO/P3Bmfn/t5Hg8oVNip6A9bAt05t8fZ2f6wUd39PftbnV7t3586TT2X75t7l9X283n4es/z/03d7vVer16unnebe8fH952jzfr7f3+u4X5/POzq3EtKaf9tRwOAy8pxENCdzhMyy7N7ax2lv8F",
       "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
+        "set_portal"
       ]
     },
     {
@@ -3733,7 +3692,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "build_msg_block",
         "attach_len_to_msg_block",
@@ -3754,7 +3713,7 @@
       "verification_key": "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"
     },
     {
-      "name": "process_log",
+      "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
       "custom_attributes": [],
       "abi": {
@@ -3771,133 +3730,181 @@
         },
         "parameters": [
           {
-            "name": "log_plaintext",
+            "name": "contract_address",
             "type": {
               "fields": [
                 {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 18,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
+                  "name": "inner",
                   "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
+                    "kind": "field"
                   }
                 }
               ],
               "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
             },
             "visibility": "private"
           },
           {
-            "name": "tx_hash",
+            "name": "nonce",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
           },
           {
-            "name": "unique_note_hashes_in_tx",
+            "name": "storage_slot",
             "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 64,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
+              "kind": "field"
             },
             "visibility": "private"
           },
           {
-            "name": "first_nullifier_in_tx",
+            "name": "note_type_id",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
           },
           {
-            "name": "recipient",
+            "name": "compute_nullifier",
             "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "packed_note_content",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
             },
             "visibility": "private"
           }
         ],
-        "return_type": null
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
       },
-      "bytecode": "H4sIAAAAAAAA/92c927bMBDG5URKIieOndG9927leHeme+/W/dsdfosWAtqHSPu09Zfw7DPDAilCovkqQJCto+9+PFHUiTy6EG1s3cFeMJ9jc5w2R5xfjMY3Kbtqjtn2tqpHXVkoxgIB4wQB4yQBY0zAmBAwThEwThMwzhAwpgSMRQLGWQLGOQLGEgHjPAFjmYCxQsC4EIAxBOciCeeSR04d24fiXY52fhvdRcC4m4BxDwHjXgLGfQSM+wkYDxAwHiRgPETAeJiA8QgB41ECxmMEjMcJGE8QMJ4kYDxFwHiagPEMAeNZAsZzBIznCRgvEDBeJGC8RMB4mYDxCgFjRsBYJWBcIWCsETDWCRgbBIxNAsYWAWObgLFDwHiVgPEaAeN1AsYbBIw3CRhvETCuEjDeJmC8Q8B4l4DxHgHjfQLGBwSMDwkYHxEwPiZgfELA+JSA8RkB43MCxhcEjC8JGF8RML4mYHxDwPg2AGMIzncknO9JOLuBOKMPFvTEYMfCLSyMwsIjLOzBwhksTMHCDyyswMIFLAxA4j0S25E4XhnsSHxGUjESdpEEiyRTJHEiSRJJiEjyQxIdktSQBIYkKyQxIUno6GA/NtiRRIIkDSRBIMkAk/iYJMckNCZ5MYmKSUpMAmKSDZNYmCRCrTDJgUkEDNJjEByDzBjExSApBiExyIdBNAxSYRAIgywYxJBBArzk4iUSL2l4CcJLBoJ4BMkIQhHkIYhCkIIgAA9ZPMTwkEAnjE4OnQhuUtwAaFzd6M+bNJIf5pia44SSe1xEV00tuz71t7POx9RRP4/8tdTonAmiv9ES/WkY/kwW2t7LR/p1XcTupDl285Evu/k4k5RZU2XWrDJSnzDXu14P66/qSsnyUaTqIraLYWzXCpY9fV20TOwXo5Btc2NRsrYnPLZ/pO8oSZl8xFOwZHG+uR4iS5RMri/snFfl7LY1Y8mEBZu035LyjWwfjEyuaax0+muvjXbY9lrP/l17rVf/x/YaW7I431yPv22vum3Z7TWJRpv0pSKbUrKflmxayX7lI9sNxdE0n8P2yRvPYH3v+X6GLTn4tS1s0/nIH9IGJ9W5RPlv3T+6vCVLlSzOx+0UzfdY2dG6hCOxytfN97I5TqnfyO8rDvtTlv0xbsc52y+po3zqKI+2dsl8njU72tA3+U20+d7Fvmq+Z9vamh1XP+lPf6vm6gs98n8R/bNB9NeH+ufC8A/jqlIY/w/1z4fh74v+chj9TdFfCaO/IfoXguhfGcYJ+s927DhhSZ33GNduOU4Q+0WLNVScsGTx2P7RcQJkyw7WikNm9wHLDjvLDjsuXfMedS141FXcoXUsedRV8agr9ajL53Wc86jLp7/KHnXNeNTls9379Jdcx7DjVVnmitOiAPqLYfQP+37po/W7ma6T2E+s8l8tP88F8fNoHEr6M+0LVyzl0/ZWn9div+TgEe6iQ7adP0D70mj3O+1GZxDSV5srnaxg6RdW+5x+L9L9iy7veva74j6Pvs5cYxBl5VdssZLNW7JEyYRRj0G44mKf/Fvxv7Zfccjs/nmr13IxGm9r+n6cjUb3c5z7r3urvfHHLuuMRn8SjY8xRpb9xCr/3Xy3+7rt3iP9Vq/ar/X6vUbv8+f6p96ipV/7EH76DXVGL3ipUwAA",
-      "debug_symbols": "tZbLCoMwEEX/ZdZZOGPV1l8ppUSNJRCiRC0U8d8bpQ9p13cTmDA5kyxOuDM1pppuV+vbbqDyPJPraj3azsdqXhRVwTpnb9f9NiXrwolsB4Ze+7UeRh1GKg+iyPiGyiyJx1vrDJV5uqi/xuLdWBSfxkyWi4rkFEY+wMgZjJzDyAWMfISRTygyJzAyw8gwBxnmIMMcZJiDDHOQYQ4yzEGGOSgwBwXmoMAcFJiDgnFwidVdB6srZ14Bop18vcsT46M3P9GiD11tmimYNWR888X69nihTLZfPxYsueKU45A46Ak=",
+      "bytecode": "H4sIAAAAAAAA/9VZy67aQAwdSEJIuAEKn3Cl7tomXJ47Fn3c30AFPqHrrLppP7qMGCcH46siYVfFEpoknhyfOXZmJqHjztY//TrhOA5tz10b9dmGtrzPKkWs0pJn50F4dh+EZ/QgPGNFnh2Bp2/peUvc+ZlL3fl5bC7iTT7BEdzk/gYAwX6HNgttF/yKCakyYZBa+Otyvs/cpSnzf8kCZmqDvyD8vg1+Sbw/1y0+joXiRqF9rVstX+Eeb0U4xuIlXPJ1wfeF+SLwfWU+rOFvzId1T5xIN1qYlOtqY50XGlsKY+u80TrXaofXSOvcmdZoRTnPGB/On/gU1Kdu+fSYLwZfxnwJ+Eh/3z5DP577FPp9hONP0IfXZ+Su65n8lH/U3aK+YgP8k82lHPD8xPVlbPRhDmLQ85npY7FuoD4W+nt9pm/wp2Nvae0ai5ieqBFp1sf+zJeBL64v4+ThPIY4iEU8Etb/QzgfhbYH99D9YyF+j8W/4C1cQ404ViRco/7++Xwfjgfh52voJ93jructvc31ci7N4Xr4qwY/s+F/JPzcBn9J+AMb/GZv82SCPysJv7Dh38xBQ5v6afaWIxv+B8Ifm+DPD7QOv3OtNXNEOJ7Adb35u6pu2SNh/JxxtdojTRgfrg+uwd43FbiOBR/P4VSIMxXiSFiZItaTItboPx1jXxFroIg1VMTSzGOqiKWpV66IVShiada9pl6UR2mf5m0b2vJOk/ZpiviVtE/TfJcnram+YkFDHF/C+v9gOg9MeFYzWnPoWacYGLswin3rek3xC4EP8c4F3z0fZw+L9XGzXmxOW7JqOds0+SwYV34N34twPsb+0tov7fsUtS6ld/8h6OotBl/BfAn4iKP07j804n+L/hh/LPj4+n9rLifuej0csHHjN6+typjb74HSt3rj+Wtx67NJ8XN3PV//q++NqA/fS+cC17Hg4/uTXIiTC3EeEYt/s0cNfV2TTnHd+rVyuVq3f3TRXJS4y/8BHIufsP6/wjmOjdp75vzjalcdX3bH3WK338+/7yYM31sXdPoDg5oBSR0fAAA=",
+      "debug_symbols": "tdfNaoQwFIbhe8k6i5z8mIm3UsoQNQ6BECVqoYj33jhM26GzLN9GiBwfN77g2dkQuu12jXmcFta+7SxNvV/jlOtpPzjrSkwp3q7Pt5k4L87c55fZ5/O4rL6srNWSs5AH1hpRnx5jCqxt1MFfBu33oLU/g0Ye75y5BgVbFHxBwQ4EkxAwmWCyhMkKJmuYbGByA5MtTL7AZFiDBGuQYA0SrEGCNUiwBgnWIMEaJFiD9L8GnXoM1k/hhXYwWgocTTha4miFozWONji6wdEWR+NqlLgaFa5GBarxqKcPX6LvUnhsTeOW+6clav2cw599ai5TH4athHOz+l2qzvSU4drc/zzqgZTmpFx9SX3RFw==",
       "brillig_names": [
-        "process_log"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "sync_notes",
+      "name": "_increase_public_balance",
       "is_unconstrained": true,
-      "custom_attributes": [],
+      "custom_attributes": [
+        "public",
+        "internal"
+      ],
       "abi": {
         "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
+          },
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
           }
         },
-        "parameters": [],
+        "parameters": [
+          {
+            "name": "to",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "amount",
+            "type": {
+              "fields": [
+                {
+                  "name": "lo",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "hi",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::uint128::U128"
+            },
+            "visibility": "private"
+          }
+        ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "bY/dCoMwDIXfJde9aKoO7KvIkKpRCqWVWgdDfPfFsUn3c3PICV8OORsM1K1Ta/0YFtDNBi70Jtng2W27gC5a5+zU5muQh2Dx5JfZ+MMuycQEulQCyA+gK8nXo3UE+lLs4gdEifLN8qzqE8ey/s/XePIK5Qd/3dneTLSmc/R6fVx9nzVJ95m+Ss0x9DSskY56WTPWBiuhJMdy9AM=",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "_increase_public_balance"
       ]
     },
     {
-      "name": "check_balance",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "view"
+        "public"
       ],
       "abi": {
         "error_types": {
+          "10502589790419500451": {
+            "error_kind": "string",
+            "string": "Function _increase_public_balance can only be called internally"
+          },
           "15238796416211288225": {
             "error_kind": "string",
             "string": "Balance too low"
           },
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
@@ -3910,6 +3917,10 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
+          "2236649814169388962": {
+            "error_kind": "string",
+            "string": "PublicImmutable already initialized"
+          },
           "3219842053230618354": {
             "error_kind": "string",
             "string": "Function check_balance can only be called statically"
@@ -3918,6 +3929,10 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "6067862452620309358": {
+            "error_kind": "string",
+            "string": "Function balance_of_public can only be called statically"
+          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -3925,34 +3940,19 @@
         },
         "parameters": [
           {
-            "name": "fee_limit",
+            "name": "selector",
             "type": {
-              "fields": [
-                {
-                  "name": "lo",
-                  "type": {
-                    "kind": "field"
-                  }
-                },
-                {
-                  "name": "hi",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::uint128::U128"
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3dbts6DIDfJde50A9FSnuV4aBou24IELRDfw5wUPTdj5NVthtpdi3KXVbxpogb0qQ+0xL1E+l58+3m6unHxe72+93D5svX583+7vrycXd32109v2w3V/e7/X7342L87406/NEqHBUefl7eHq4fHi/vHzdfNKLZbm5uvx0+kulu8X23v9l8QfuyTYQxKHoVxmBsL+x1Rjio/s5BeTcW/me70RoWunNUCgVKpsSSNSVKlFMywUUlE0hNIwY0+lW4+ximEXtL8c7eejpFDCbvjh3ccXraHa3QxgJrPTxx7VxO2mMUDr6XNd3nozt4Vu44fV7unBcdPC86eF50SJ2XO3Be7oSzcsfbj3bHRXeMMm/cyVThYKKwB4JBGkNG2vZ3BqNGshlRowNEL4w208Kud8IZGose+Xnhx+EXjPBj8SPhx+DXlUH4sfhJ/LH4aYk/Hj8Ufhx+Rgk/Fj8n/Fj8gvDj8LMg/Fj8pP82yw9V5If6lB9I/sLjJ/kzi9/HD1T/ffx6WXwreuBH8v7y+En/g8XPy/vL4yfxx+IXJP54/CT+OPyskvEXHj8Qfix+Mv7C4qdl/pzHT8ZfWPyM9N94/GT8hcXPSv6cgSKTQikUkEw3AwUESgpFcoIUipNEMwNFWu8UCkqTnIEi41QpFJImOQNFmuQMFBkmSqHIbydyUKRJTqHIrxxyUCRSEiigJHnLQJHxlBSKluQtA0UiJYXS6BpXYwco4E6huDY7hKRD9IKsLRY+EMQ2K6AlBDUO5UOvE4Jt1lYVCVKbXbCaBNtsHCoS9G127hYRJIo31hSStrjRMYOKBBtdxlqToLTFXIJtjhHXI+iUZDNcgtKSMAk2uiFFTYISg0yCRrIZLkHJZrgEJZthErSSzXAJSkvCJAjSknAJSkvCJOhknoRLEITgHMGg+83Xg0kJSjbDJIgSg1yCFWaatPfRwnhOP0/Qunggg0WavjFhFCU/4NO/ji5wNWYZ/5Dnfy3zGhub/BnP3zEXQ37Ocxv6mgLfmsi4Y32sVwjUIJ09FoO0j36QMXpaWGtlhypLIY7Fj2WlDy8rDWXVM0eAdLeIW4dpdIOw1bkAAIQYLoA4SKPKCLveDRcG0c6hjgq+Y1PpBqkYK1QyVLxQSalYFCopFdCfiUqIjSiQcmMqx6J+qgCYLKr7TE+V+kW3XT9EJUX9TE+V+tSoK2o4Leo7+ovBzqSZEKI/5EZ5XbQQ1rZAq5eBKpTBad1bMHhqwcPqFlYvQ6jxHHwYnkMSrSGsbIHesbaFa4HWtqD16hZwbQtm9TK8Y+6Za6HGG9d398mRPrVga9Qa5HsLY+FXC2FtC7B6GaDKc8DhOZzWfORgdQt+bQtoVreAa1sgvbqF1cvg1eoWKkQrqr7m6/p7051Fa0N8PS2MBtyP4+3eLC3vUckVKNkSS9YXKDW64Y9VvRdWj298hIJtLtmcgSKRkkKhNhdzTEPxba7PmIEikZJCCRIpGSjQ5u4CoS+fVW5aWKt+FUVXVJ8QbHR/hmoEQ6On+C4iqEcz+U4nBNtMlyoSbHTrmYoEGz2LtiZBaYvnCaLry+eTlqTR5e6LCILqp0lBJTEIbS41rkiw0a2+axKUbIZJsNFNxBcRdKYvn3MqIdjmBnMVCZLEIJegtMVMgu+Y0hOCkwQbHTStSVCyGR5BrWSAkI9QRqm5CBs9LLQqQolCLsJGjwxdhpD6XzK7YFKE0iJzEVqJQi7CRk/UrIpQhvvZCGWMgYtQBvz5CKVF5iKUAet5hHbY4cZanSCUEWs+QmmR2QilReYibPRoz6oIpUXmImz0VI+qCCWpYSLUjR5JWhWhJDVshJLUcBHK9BMfoSQ18wiBeoSYTD9pI1HIRWhl4J+NUFpkLsJGz1aoilB6J1yETqKQjVDqQt6vJTqE0jvhIkTJC9kIpXfCRUjSIr9FeKBi8gdgUL8TL4FNdPL7ggSIhoJL7eR3wpjUsfml3TM6uFxHZztd0xtTdFquSCuUaOV//T2rVWTLFtmyRbagyBYU2XJFz8sV2cKicuWP0ZnTIlOkhSVavuhNye84NVnH2PzWy0HFPciDSXUK6iXIH4o8aQfyW/lO6+R3wJjRgQKd5fUs5I/znNEpsAPL62bIdwJndArsYIEdzMZ1cDGuAyVLsYBUgU6Bnfwyhxkdv1wnFNgJy+242Vwgp0OLn+lvDkmf0Smwk9+NdVonPzg8o7P8XXBgC3SW1we/OfxxRics18ECO1hQHiqIHSp4Pn55HGA+PwMP8XQC8G5oTV6V8ktvIaj+eIyg3Vjppbv49/J+d3m1v3noVA7fPd1eP+7ubl8vH//7Gb+5ut/t97sfFz/v765vvj3d31zs764P323U65+vFnBrkQ7OHC6Nha2x4XB5qK6tpm2XUHdWO8v/Aw==",
+      "bytecode": "JgACBAEnAAABBIBGJgAABAMmAgIEASYCAwQAHxgAAwACgEUtCIBFAAEkAAAARSQAAABiJwIAAQSARiYCAgQAOg0AAQACKgCAQwAAAAAAAAAAAQAAAAAAAAAAJwCARAQAAyUkAAAKrygCAAIA7Lr/Vgo4AQIDJgIEBAAmAgYEAwA4BAYFLAgBAgAQAQUBJgMCBAEAKAICBSwOBAUAKAUCBSwOBAUmAgUEAwA4AgUELA0CBAAoBAIELA4EAiYCBAQAJgIFAAAmAgYEASMCAAMAAADXIgAAAvssCAEDJgIHBAIAEAEHASYDAwQBACgDAgcfPAAGAAYABywNAwcAKAcCBywOBwMsCAEHAAABAgEsDgMHLAgBAwAAAQIBLA4EAyYCCQQKLAgACiwMBwssDAMMABAACQAkAAAK2CwEAAAsDAsIJgIHBAksCAAJLAwICgAQAAcAJAAAC1MsBAAALAwKAyYCBwACLgwABwAILAgBCSYCCgQCABABCgEmAwkEAQAoCQIKLAwKCywOCAsmAgoECywIAAssDAkMABAACgAkAAALUywEAAAsDAwICjgIBQkjAgAJAAABwCYCCgQAOwkBCigCAAgAO5rKAi4MAAgACQo4CQUKIwIACgAAAeEkAAALrCcCAAkA3q0vDAAJAAgmAgwEDSwIAA0tCIBDAA4AEAAMACQAAAu+LAQAACwMDggsDA8JLAwQCiwMEQssDQgMACgMAgwsDgwILAgBDAAAAQIBLA4IDCwNCQgAKAgCCCwOCAksCAEIAAABAgEsDgkILAgBCQAAAQIBLA4KCSwIAQoAAAECASwOCwomAgsEDSwIAA0sDAwOLAwIDywMCRAsDAoRLAwDEgAQAAsAJAAADGUsBAAAJgINBA4sCAAOLAwMDywMCBAsDAkRLAwKEgAQAA0AJAAADZQsBAAALAwPCy8MAAMAByYCAwADLwwACwADLA0CAwAoAwIDLA4DAgAoAgIILA0IByYCCQQCADgICQM6DQADAAciAAAC+ygCAAMAgV0ofwo4AQMHJgIDAQAmAggALSYCCQQCJgIKAAEjAgAHAAADKiIAAAVRLAgBByYCCwQEABABCwEmAwcEAQAoBwILHywABoBEAAssDQcLACgLAgssDgsHLAgBCwAAAQIBLAgBDAAAAQIBACgHAg4AOA4EDywNDw0AKAcCDwA4DwYQLA0QDgAoBwIQADgQCREsDREPLAgBECYCEQQDABABEQEmAxAEAQAoEAIRLAwREiwODhIAKBICEiwODxIsDgcLLQqARAAMJgIMBBEsCAARLAwQEgAQAAwAJAAADhgsBAAALAwSBywMEwssCAEMAAABAgEsDgMMLAgBDgAAAQIBLA4FDiwIAQ8AAAECASYCEABKLA4QDx4CABABHgIAEQAKOBAREiMCABIAAAQxJAAADmQmAhQEFSwIABUsDAwWLAwOFywMDxgsDAoZLAwIGiwMDRsAEAAUACQAAA52LAQAACwMFhAsDBcRLAwYEiwMGRMmAhYEFywIABcsDBAYLAwRGSwMEhosDBMbABAAFgAkAAAQHSwEAAAsDBgULAwZFQA4FAcQHAwQEQUcDBEHAAI4EAcRCSgAEYBDABAAOBULEQA4ERALHAwLEQUcDBEQAAo4EAsRIwIAEQAABOEkAAAQdCYCFAQVLAgAFSwMDBYsDA4XLAwPGCwMChksDAgaLAwNGwAQABQAJAAADnYsBAAALAwWCywMFxEsDBgSLAwZEwUoABCAQwAMADgHDA0vDAANABMAKAICDSwNDQwmAg4EAgA4DQ4HOg0ABwAMIgAABVEoAgAHAB+aC34KOAEHCyMCAAsAAAVsIgAAB6wsCAELJgIMBAMAEAEMASYDCwQBACgLAgwfPAAGAAkADCwNCwwAKAwCDCwODAssCAEMAAABAgEsCAENAAABAgEAKAsCDwA4DwQQLA0QDgAoCwIQADgQBhEsDREPLAgBECYCEQQDABABEQEmAxAEAQAoEAIRLAwREiwODhIAKBICEiwODxIsDgsMLA4JDSYCDQQRLAgAESwMEBIAEAANACQAAA4YLAQAACwMEgssDBMMLAgBDQAAAQIBLA4DDSwIAQ4AAAECASwOBQ4sCAEPAAABAgEmAhAAOiwOEA8eAgAQCQo4EAoRIwIAEQAABl4kAAAQhh4CABABJgIVBBYsCAAWLAwNFywMDhgsDA8ZLAwKGiwMCBssDBAcABAAFQAkAAAOdiwEAAAsDBcRLAwYEiwMGRMsDBoUJgIPBBUsCAAVLAwRFiwMEhcsDBMYLAwUGQAQAA8AJAAAEB0sBAAALAwWDSwMFw4cDA4QBRwMEA8AHAwPDgUcDAwQBRwMEA8AHAwPDAUmAhAEESwIABEsDA4SLAwMEwAQABAAJAAAEJgsBAAALAwSDxwMDQ4FHAwODAAcDAwNBRwMCw4FHAwODAAcDAwLBSYCDgQQLAgAECwMDREsDAsSABAADgAkAAAQmCwEAAAsDBEMCjgPCgsjAgALAAAHbiIAAAdlLAwPByIAAAd3LAwMByIAAAd3CjgHBQsKOAsDByMCAAcAAAeOJAAAEPkAKAICDCwNDAsmAg0EAgA4DA0HOg0ABwALIgAAB6woAgACAP95SfIKOAECByMCAAcAAAfHIgAACVgsCAEBJgICBAIAEAECASYDAQQBACgBAgIfPAAGAAYAAiwNAQIAKAICAiwOAgEsCAECAAABAgEsDgECLAgBAQAAAQIBLA4EASYCBwQLLAgACywMAgwsDAENABAABwAkAAAK2CwEAAAsDAwGACgGAgIAOAIEBywNBwEsCAECAAABAgEsDgMCLAgBBgAAAQIBLA4FBiwIAQUAAAECASYCBwAXLA4HBR4CAAcJCjgHCgsjAgALAAAIgiQAABELJgIOBA8sCAAPLAwCECwMBhEsDAUSLAwKEywMCBQsDAEVABAADgAkAAAOdiwEAAAsDBAHLAwRCywMEgwsDBMNJgIFBA4sCAAOLAwHDywMCxAsDAwRLAwNEgAQAAUAJAAAEB0sBAAALAwPASwMEAImAgYEAiYCCAQDADgGCAcsCAEFABABBwEmAwUEAQAoBQIHLA4GBwAoBwIHLA4GByYCBwQDADgFBwYsDAYHLA4BBwAoBwIHLA4CBwAoBQIGLA0GAiYCBwQCADgGBwE6DQABAAIiAAAJWCYCAQJjJgICAnMmAgUCbyYCBgJVJgIHAnQmAggCZSYCCQJ3JgIKAm4mAgsCciYCDAJsJgINAiAmAg4CaywIAQ8mAhAEEQAQARABJgMPBAEAKA8CECwMEBEsDgYRACgRAhEsDgoRACgRAhEsDg4RACgRAhEsDgoRACgRAhEsDgURACgRAhEsDgkRACgRAhEsDgoRACgRAhEsDg0RACgRAhEsDgIRACgRAhEsDggRACgRAhEsDgwRACgRAhEsDggRACgRAhEsDgERACgRAhEsDgcRACgRAhEsDgURACgRAhEsDgsRJgIBAQEKOAMBAiMCAAIAAAquJgIFBBIsCAEGJgIHBBIAEAEHASwMBgcpAwAHBeWPmFkHMWKQACgHAgcAKA8CCCYCCQQQLQQACIADLQQAB4AELQQACYAFJAAAER0mAggEEAA4BwgHLA4EBwAoBwIHOw0GBSUnAIAEBHgADQAAAIAEgAMjAIADAAAK1ykBAAEF96Hzr6Wt1Mo7AQECJSQAAAqvLA0BAywNAgQmAgYEAQw4BAYHIwIABwAACvwkAAARYwAoAwIGADgGBAcsDQcFLAgBBiYCBwQCABABBwEmAwYEAQAoBgIHLAwHCCwOBQgmAgUEAQA4BAUHDjgEBwgjAgAIAAALRiQAABB0LA4DASwOBwIsDAYBJSQAAAqvJgICBAAAKAECBAA4BAIFLA0FAxwMAwEAKwIAAgAAAAAAAAAAAAAAAAD//////////////////////////w44AQIEIwIABAAAC6ckAAARdSwMAwElKQEAAQUfCi0n3IKHojsBAQIlJAAACq8mAgIAACwIAQMmAgQEBAAQAQQBJgMDBAEAKAMCBCwMBAUsDgIFACgFAgUsDgIFACgFAgUsDgIFLA0DBAAoBAIELA4EAywIAQQmAgUEBQAQAQUBJgMEBAEAKAQCBSwMBQYsDgIGACgGAgYsDgIGACgGAgYsDgIGACgGAgYsDgEGJgIBBAAmAgIBACwMAgUsDAEGLAwEAiwMBQQsDAMBLAwGAyUkAAAKrywNAwYsDQQHJgIIAQAKOAcICSMCAAkAAAyNJgIKBAA7CQEKCygABoBEAAcmAgYEASMCAAcAAA0gIgAADKcsDQEHLA0CCCwNAwksDQQKJgIMBAMMOAkMDSMCAA0AAAzOJAAAEWMtBAAHgAMnAIAEBAAEJAAAEYctCIAFAAsAKAsCDAA4DAkNLA4FDQA4CQYFDjgJBQcjAgAHAAANCyQAABB0LA4LASwOCAIsDgUDLA4KBCIAAA2TJgIHBAgsCAAILAwBCSwMAgosDAMLLAwEDAAQAAcAJAAAEhUsBAAALA0BBywNAggsDQQJJgIKBAAtBAAHgAMnAIAEBAAEJAAAEYctCIAFAAsAKAsCDAA4DAoNLA4FDSwOCwEsDggCLA4GAywOCQQiAAANkyUkAAAKrywNBAUmAgYBAAo4BQYHIwIABwAADbgmAggEADsJAQgmAgUEBiwIAAYsDAEHLAwCCCwMAwksDAQKABAABQAkAAASFSwEAAAsDQEFLA0CBiwNAwcsDgUBLA4GAiwOBwMmAgEBASwOAQQmAgEEAAAoBgIDADgDAQQsDQQCLAwCASUkAAAKryYCAgQAACgBAgQAOAQCBSwNBQMcDAMEBRwMBAIAJgIDBAEAKAECBQA4BQMGLA0GBBwMBAMFHAwDAQAsDAEDLAwCASwMAwIlKQEAAQWRwLHE75k9ozsBAQIlJAAACq8sCAEIJgIJBAMAEAEJASYDCAQBACgIAgksDAkKLA4ECgAoCgIKLA4GCioCAAQAAAAAAAAAAAIAAAAAAAAAACYCDAQNLAgADSwMBA4AEAAMACQAAAu+LAQAACwMDgYsDA8JLAwQCiwMEQssDQYEACgEAgQsDgQGLAgBBAAAAQIBLA4GBCwNCQYAKAYCBiwOBgksCAEGAAABAgEsDgkGLAgBCQAAAQIBLA4KCSwIAQoAAAECASwOCwomAgsEACYCDAQBJgINBAIsDAsHIgAAD0oMOAcNBSMCAAUAAA+tIgAAD1wmAgcECywIAAssDAQMLAwGDSwMCQ4sDAoPABAABwAkAAANlCwEAAAsDAwFJgIEAAAKOAUEBiYCBAEACjgGBAcjAgAHAAAPqCQAABNyLAwFBCUjAgAFAAAPuiIAABAPJgILBAIMOAcLDiMCAA4AAA/RJAAAEWMAKAgCCwA4CwcOLA0OBSYCCwQOLAgADiwMBA8sDAYQLAwJESwMChIsDAUTABAACwAkAAAMZSwEAAAiAAAQDwA4BwwFLAwFByIAAA9KJAAACq8uDAAEAAUcDAUEACoCAAYA/////////////////////w44BAYHIwIABwAAEFQkAAARdRwMBQYFHAwGBAACOAUEBgkoAAaAQwAFLAwEASwMBQIlKQEAAQVFp8pxGUHkFTsBAQIlKQEAAQUsry1Jt6zm8jsBAQIlJAAACq8MOAECBCMCAAQAABDmIgAAEK8MOAIBBSMCAAUAABDPIgAAEMEmAgEAASwMAQQiAAAQ3SYCAQACLAwBBCIAABDdLAwEAyIAABD0JgIBAAAsDAEDIgAAEPQsDAMBJSkBAAEF03sUmhjFAKE7AQECJSkBAAEFVDVgwHJdM247AQECJQEAgAOABYAHLQCAA4AILQCABIAJCwCACIAHgAojAIAKAAARYi0BgAiABi0CgAaACQEAgAgAAoAIAQCACQACgAkiAAARMSUpAQABBeidCf6hES0OOwEBAiUpAQABBVoC5Bu1HqmfOwEBAiUtAYADgAYLAIAGAAKAByMAgAcAABGiIgAAEa0tAIADgAUiAAASFC0AAAGABQEAAAGABAABAQCAA4AEgAktAIADgAotAIAFgAsLAIAKgAmADCMAgAwAABIALQGACoAILQKACIALAQCACgACgAoBAIALAAKACyIAABHPJwGABQQAAQMAgAYAAoAGIgAAEhQlJAAACq8mAgYEACYCBwQBLAwGBSIAABItDSgABYBEAAYjAgAGAAASnSIAABJCLA0BBSwNAgYsDQMHLA0ECCYCCQQELAgBCiYCCwQFABABCwEmAwoEAQAoBgILJgIMBAQAKAoCDT4PAAsADSwNCgYAKAYCBiwOBgosDgUBLA4KAiwOBwMsDggEJSwNAwYMOAUGCAA4BQcGIwIACAAAErgiAAATaSwNAQgsDQIJLA0DCiwNBAsmAg0EBAw4BQ0OIwIADgAAEt8kAAARYwAoCQINADgNBQ4sDQ4MJgIOBAMMOAUODyMCAA8AABMEJAAAEWMAKAgCDgA4DgUPLA0PDQA4DA0OJgINBAQMOAUNDyMCAA8AABMuJAAAEWMtBAAJgAMnAIAEBAAFJAAAEYctCIAFAAwAKAwCDQA4DQUPLA4ODywOCAEsDgwCLA4KAywOCwQiAAATaSwMBgUiAAASLSkBAAEFAtxuJ4B2Ep07AQECJS0AGMoYyg==",
+      "debug_symbols": "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",
       "brillig_names": [
-        "check_balance"
+        "public_dispatch"
       ]
     }
   ],
@@ -4022,7 +4022,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "portal_address",
+                    "name": "to",
                     "type": {
                       "fields": [
                         {
@@ -4033,11 +4033,11 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
                   },
                   {
-                    "name": "initial_mint",
+                    "name": "amount",
                     "type": {
                       "fields": [
                         {
@@ -4059,12 +4059,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::initialize_parameters"
+                "path": "FeeJuice::_increase_public_balance_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::initialize_abi"
+          "path": "FeeJuice::_increase_public_balance_abi"
         },
         {
           "fields": [
@@ -4166,7 +4166,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "to",
+                    "name": "owner",
                     "type": {
                       "fields": [
                         {
@@ -4179,36 +4179,36 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
+                  }
+                ],
+                "kind": "struct",
+                "path": "FeeJuice::balance_of_public_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "fields": [
+                  {
+                    "name": "lo",
+                    "type": {
+                      "kind": "field"
+                    }
                   },
                   {
-                    "name": "amount",
+                    "name": "hi",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "lo",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "hi",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "std::uint128::U128"
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "FeeJuice::_increase_public_balance_parameters"
+                "path": "std::uint128::U128"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::_increase_public_balance_abi"
+          "path": "FeeJuice::balance_of_public_abi"
         },
         {
           "fields": [
@@ -4253,7 +4253,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "owner",
+                    "name": "portal_address",
                     "type": {
                       "fields": [
                         {
@@ -4264,161 +4264,161 @@
                         }
                       ],
                       "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "FeeJuice::balance_of_public_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "fields": [
-                  {
-                    "name": "lo",
-                    "type": {
-                      "kind": "field"
+                      "path": "authwit::aztec::protocol_types::address::eth_address::EthAddress"
                     }
                   },
                   {
-                    "name": "hi",
+                    "name": "initial_mint",
                     "type": {
-                      "kind": "field"
+                      "fields": [
+                        {
+                          "name": "lo",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "hi",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "std::uint128::U128"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "std::uint128::U128"
+                "path": "FeeJuice::initialize_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "FeeJuice::balance_of_public_abi"
+          "path": "FeeJuice::initialize_abi"
         }
       ]
     }
   },
   "file_map": {
     "103": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/history/public_storage.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, constants::GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n    hash::poseidon2_hash_with_separator, utils::field::full_field_less_than,\n};\nuse dep::protocol_types::merkle_tree::root::root_from_sibling_path;\n\nuse crate::oracle::get_public_data_witness::get_public_data_witness;\n\ntrait PublicStorageHistoricalRead {\n    fn public_storage_historical_read(\n        header: BlockHeader,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field;\n}\n\nimpl PublicStorageHistoricalRead for BlockHeader {\n    fn public_storage_historical_read(\n        self,\n        storage_slot: Field,\n        contract_address: AztecAddress,\n    ) -> Field {\n        // 1) Compute the leaf index by siloing the storage slot with the contract address\n        let public_data_tree_index = poseidon2_hash_with_separator(\n            [contract_address.to_field(), storage_slot],\n            GENERATOR_INDEX__PUBLIC_LEAF_INDEX,\n        );\n\n        // 2) Get the membership witness for the tree index.\n        /// Safety: The witness is only used as a \"magical value\" that makes the proof below pass. Hence it's safe.\n        let witness = unsafe {\n            get_public_data_witness(\n                self.global_variables.block_number as u32,\n                public_data_tree_index,\n            )\n        };\n\n        // 3) The witness is made up of two parts: the preimage of the leaf and the proof that it exists in the tree.\n        // We first prove that the witness is indeed valid for the public data tree, i.e. that the preimage is of a\n        // value present in the tree. Note that `hash` returns not just the hash of the value but also the metadata\n        // (slot, next index and next slot).\n        assert_eq(\n            self.state.partial.public_data_tree.root,\n            root_from_sibling_path(witness.leaf_preimage.hash(), witness.index, witness.path),\n            \"Proving public value inclusion failed\",\n        );\n\n        // 4) Now that we know the preimage is valid, we determine the value that's represented by this tree entry. Here\n        // we have two scenarios:\n        // 1. The tree entry is initialized, and the value is the same as the one in the witness\n        // 2. The entry was never initialized, and the value is default zero (the default)\n        // The code below is based on the same checks in `validate_public_data_reads` in `base_rollup_inputs`.\n        let preimage = witness.leaf_preimage;\n\n        let is_less_than_slot = full_field_less_than(preimage.slot, public_data_tree_index);\n        let is_next_greater_than = full_field_less_than(public_data_tree_index, preimage.next_slot);\n        let is_max = ((preimage.next_index == 0) & (preimage.next_slot == 0));\n        let is_in_range = is_less_than_slot & (is_next_greater_than | is_max);\n\n        let value = if is_in_range {\n            0\n        } else {\n            assert_eq(\n                preimage.slot,\n                public_data_tree_index,\n                \"Public data tree index doesn't match witness\",\n            );\n            preimage.value\n        };\n\n        value\n    }\n}\n"
     },
     "120": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/messaging.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/messaging.nr",
       "source": "use crate::{\n    hash::{compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash},\n    oracle::get_l1_to_l2_membership_witness::get_l1_to_l2_membership_witness,\n};\n\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    merkle_tree::root::root_from_sibling_path,\n};\n\npub fn process_l1_to_l2_message(\n    l1_to_l2_root: Field,\n    contract_address: AztecAddress,\n    portal_contract_address: EthAddress,\n    chain_id: Field,\n    version: Field,\n    content: Field,\n    secret: Field,\n    leaf_index: Field,\n) -> Field {\n    let secret_hash = compute_secret_hash(secret);\n    let message_hash = compute_l1_to_l2_message_hash(\n        portal_contract_address,\n        chain_id,\n        contract_address,\n        version,\n        content,\n        secret_hash,\n        leaf_index,\n    );\n\n    // We prove that `message_hash` is in the tree by showing the derivation of the tree root, using a merkle path we\n    // get from an oracle.\n    /// Safety: The witness is only used as a \"magical value\" that makes the merkle proof below pass. Hence it's safe.\n    let (_leaf_index, sibling_path) =\n        unsafe { get_l1_to_l2_membership_witness(contract_address, message_hash, secret) };\n\n    let root = root_from_sibling_path(message_hash, leaf_index, sibling_path);\n    assert_eq(root, l1_to_l2_root, \"Message not in state\");\n\n    compute_l1_to_l2_message_nullifier(message_hash, secret)\n}\n"
     },
-    "136": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
+    "137": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "138": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
+    "139": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n    let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "140": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
+    "141": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_l1_to_l2_membership_witness.nr",
       "source": "use crate::utils::array;\nuse dep::protocol_types::{address::AztecAddress, constants::L1_TO_L2_MSG_TREE_HEIGHT};\n\n/// Returns the leaf index and sibling path of an entry in the L1 to L2 messaging tree, which can then be used to prove\n/// its existence.\npub unconstrained fn get_l1_to_l2_membership_witness(\n    contract_address: AztecAddress,\n    message_hash: Field,\n    secret: Field,\n) -> (Field, [Field; L1_TO_L2_MSG_TREE_HEIGHT]) {\n    let returned_message =\n        get_l1_to_l2_membership_witness_oracle(contract_address, message_hash, secret);\n    let leaf_index = returned_message[0];\n    let sibling_path = array::subarray(returned_message, 1);\n\n    (leaf_index, sibling_path)\n}\n\n// Obtains membership witness (index and sibling path) for a message in the L1 to L2 message tree.\n#[oracle(getL1ToL2MembershipWitness)]\nunconstrained fn get_l1_to_l2_membership_witness_oracle(\n    _contract_address: AztecAddress,\n    _message_hash: Field,\n    _secret: Field,\n) -> [Field; L1_TO_L2_MSG_TREE_HEIGHT + 1] {}\n"
     },
-    "143": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
+    "144": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/get_public_data_witness.nr",
       "source": "use crate::utils::array;\nuse dep::protocol_types::{constants::PUBLIC_DATA_TREE_HEIGHT, data::PublicDataTreeLeafPreimage};\n\nglobal LEAF_PREIMAGE_LENGTH: u32 = 4;\nglobal PUBLIC_DATA_WITNESS: u32 = 45;\n\npub struct PublicDataWitness {\n    pub index: Field,\n    pub leaf_preimage: PublicDataTreeLeafPreimage,\n    pub path: [Field; PUBLIC_DATA_TREE_HEIGHT],\n}\n\n#[oracle(getPublicDataTreeWitness)]\nunconstrained fn get_public_data_witness_oracle(\n    _block_number: u32,\n    _public_data_tree_index: Field,\n) -> [Field; PUBLIC_DATA_WITNESS] {}\n\npub unconstrained fn get_public_data_witness(\n    block_number: u32,\n    public_data_tree_index: Field,\n) -> PublicDataWitness {\n    let fields = get_public_data_witness_oracle(block_number, public_data_tree_index);\n    PublicDataWitness {\n        index: fields[0],\n        leaf_preimage: PublicDataTreeLeafPreimage {\n            slot: fields[1],\n            value: fields[2],\n            next_index: fields[3] as u32,\n            next_slot: fields[4],\n        },\n        path: array::subarray(fields, 1 + LEAF_PREIMAGE_LENGTH),\n    }\n}\n"
     },
-    "149": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+    "150": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note_content,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        packed_note_content,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note_content: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::unpack_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
     "152": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
       "source": "use dep::protocol_types::{address::AztecAddress, traits::Packable};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n    address: Field,\n    storage_slot: Field,\n    block_number: Field,\n    length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> [Field; N] {\n    storage_read_oracle(\n        address.to_field(),\n        storage_slot,\n        block_number as Field,\n        N as Field,\n    )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> T\nwhere\n    T: Packable<N>,\n{\n    T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n    use crate::oracle::storage::{raw_storage_read, storage_read};\n    use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n    use crate::test::mocks::mock_struct::MockStruct;\n    use std::test::OracleMock;\n\n    global address: AztecAddress = AztecAddress::from_field(29);\n    global slot: Field = 7;\n    global block_number: u32 = 17;\n\n    #[test]\n    unconstrained fn test_raw_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n        assert_eq(read[0], 13);\n        assert_eq(read[1], 42);\n    }\n\n    #[test]\n    unconstrained fn test_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: MockStruct = storage_read(address, slot, block_number);\n        assert_eq(read.a, 13);\n        assert_eq(read.b, 42);\n    }\n}\n"
     },
-    "155": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
+    "154": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
       "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<N> for Map<K, T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
-    "162": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
+    "161": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_immutable.nr",
       "source": "use crate::{\n    context::{PrivateContext, PublicContext, UnconstrainedContext},\n    state_vars::storage::Storage,\n    utils::with_hash::WithHash,\n};\nuse dep::protocol_types::{constants::INITIALIZATION_SLOT_SEPARATOR, traits::Packable};\n\n/// Stores an immutable value in public state which can be read from public, private and unconstrained execution\n/// contexts.\n///\n/// Leverages `WithHash<T>` to enable efficient private reads of public storage. `WithHash` wrapper allows for\n/// efficient reads by verifying large values through a single hash check and then proving inclusion only of the hash\n/// in the public storage. This reduces the number of required tree inclusion proofs from O(M) to O(1).\n///\n/// This is valuable when T packs to multiple fields, as it maintains \"almost constant\" verification overhead\n/// regardless of the original data size.\n///\n/// # Optimizing private reads in your contract\n/// Given that reading T from public immutable in private has \"almost constant\" constraints cost for different sizes\n/// of T it is recommended to group multiple values into a single struct when they are being read together. This can\n/// typically be some kind of configuration set up during contract initialization. E.g.:\n///\n/// ```noir\n/// use dep::aztec::protocol_types::{address::AztecAddress, traits::Packable};\n/// use std::meta::derive;\n///\n/// #[derive(Eq, Packable)]\n/// pub struct Config \\{\n///     pub address_1: AztecAddress,\n///     pub value_1: U128,\n///     pub value_2: u64,\n///     ...\n/// }\n/// ```\n///\n// docs:start:public_immutable_struct\npub struct PublicImmutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_immutable_struct\n\n/// `WithHash<T>` stores both the packed value (using N fields) and its hash (1 field), requiring N = M + 1 total\n/// fields.\nimpl<T, Context, let M: u32, let N: u32> Storage<N> for PublicImmutable<T, Context>\nwhere\n    WithHash<T, M>: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, Context> PublicImmutable<T, Context> {\n    // docs:start:public_immutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicImmutable { context, storage_slot }\n    }\n    // docs:end:public_immutable_struct_new\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicImmutable<T, &mut PublicContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\n{\n    // docs:start:public_immutable_struct_write\n    pub fn initialize(self, value: T) {\n        // We check that the struct is not yet initialized by checking if the initialization slot is 0\n        let initialization_slot = INITIALIZATION_SLOT_SEPARATOR + self.storage_slot;\n        let init_field: Field = self.context.storage_read(initialization_slot);\n        assert(init_field == 0, \"PublicImmutable already initialized\");\n\n        // We populate the initialization slot with a non-zero value to indicate that the struct is initialized\n        self.context.storage_write(initialization_slot, 0xdead);\n        self.context.storage_write(self.storage_slot, WithHash::new(value));\n    }\n    // docs:end:public_immutable_struct_write\n\n    // Note that we don't access the context, but we do call oracles that are only available in public\n    // docs:start:public_immutable_struct_read\n    pub fn read(self) -> T {\n        WithHash::public_storage_read(*self.context, self.storage_slot)\n    }\n    // docs:end:public_immutable_struct_read\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicImmutable<T, UnconstrainedContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\n{\n    pub unconstrained fn read(self) -> T {\n        WithHash::unconstrained_public_storage_read(self.context, self.storage_slot)\n    }\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicImmutable<T, &mut PrivateContext>\nwhere\n    T: Packable<T_PACKED_LEN> + Eq,\n{\n    pub fn read(self) -> T {\n        WithHash::historical_public_storage_read(\n            self.context.get_block_header(),\n            self.context.this_address(),\n            self.storage_slot,\n        )\n    }\n}\n"
     },
-    "163": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
+    "162": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UnconstrainedContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<N> for PublicMutable<T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicMutable<T, &mut PublicContext>\nwhere\n    T: Packable<T_PACKED_LEN>,\n{\n    // docs:start:public_mutable_struct_read\n    pub fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write(self, value: T) {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T, let T_PACKED_LEN: u32> PublicMutable<T, UnconstrainedContext>\nwhere\n    T: Packable<T_PACKED_LEN>,\n{\n    pub unconstrained fn read(self) -> T {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
     "18": {
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    /// Safety: borrow is enforced to be boolean due to its type.\n    /// if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    /// if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        /// Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            /// Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        /// Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        /// Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
-    "184": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+    "183": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
     "19": {
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        /// Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "193": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
+    "192": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/with_hash.nr",
       "source": "use crate::{\n    context::{PublicContext, UnconstrainedContext},\n    history::public_storage::PublicStorageHistoricalRead,\n    oracle,\n};\nuse dep::protocol_types::{\n    address::AztecAddress, block_header::BlockHeader, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check\n/// and then proving inclusion only of the hash in public storage. This reduces the number\n/// of required tree inclusion proofs from `N` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `N`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let N: u32> {\n    value: T,\n    packed: [Field; N],\n    hash: Field,\n}\n\nimpl<T, let N: u32> WithHash<T, N>\nwhere\n    T: Packable<N> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn unconstrained_public_storage_read(\n        context: UnconstrainedContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        let historical_block_number = header.global_variables.block_number as u32;\n\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot (since due to kernel siloing the storage is not contiguous). Instead, we\n        // get an oracle to provide us the values, and instead we prove inclusion of their hash, which is both a much\n        // smaller proof (a single slot), and also independent of the size of T (except in that we need to pack and hash T).\n        let hint = WithHash::new(\n            /// Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe {\n                oracle::storage::storage_read(address, storage_slot, historical_block_number)\n            },\n        );\n\n        let hash = header.public_storage_historical_read(storage_slot + N as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero\n            // (i.e. the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let N: u32> Packable<N + 1> for WithHash<T, N>\nwhere\n    T: Packable<N>,\n{\n    fn pack(self) -> [Field; N + 1] {\n        let mut result: [Field; N + 1] = std::mem::zeroed();\n        for i in 0..N {\n            result[i] = self.packed[i];\n        }\n        result[N] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; N + 1]) -> Self {\n        let mut value_packed: [Field; N] = std::mem::zeroed();\n        for i in 0..N {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[N];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n\nmod test {\n    use crate::{\n        oracle::random::random,\n        test::{\n            helpers::{cheatcodes, test_environment::TestEnvironment},\n            mocks::mock_struct::MockStruct,\n        },\n        utils::with_hash::WithHash,\n    };\n    use dep::protocol_types::hash::poseidon2_hash;\n    use dep::std::{mem, test::OracleMock};\n\n    global storage_slot: Field = 47;\n\n    #[test]\n    unconstrained fn create_and_recover() {\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n        let recovered = WithHash::unpack(value_with_hash.pack());\n\n        assert_eq(recovered.value, value);\n        assert_eq(recovered.packed, value.pack());\n        assert_eq(recovered.hash, poseidon2_hash(value.pack()));\n    }\n\n    #[test]\n    unconstrained fn read_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n\n        // We should get zeroed value\n        let expected: MockStruct = mem::zeroed();\n        assert_eq(result, expected);\n    }\n\n    #[test]\n    unconstrained fn read_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value = MockStruct { a: 5, b: 3 };\n        let value_with_hash = WithHash::new(value);\n\n        // We write the value with hash to storage\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            storage_slot,\n            value_with_hash.pack(),\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let result = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n\n        assert_eq(result, value);\n    }\n\n    #[test(should_fail_with = \"Non-zero hint for zero hash\")]\n    unconstrained fn test_bad_hint_uninitialized_value() {\n        let mut env = TestEnvironment::new();\n\n        env.advance_block_to(6);\n\n        let value_packed = MockStruct { a: 1, b: 1 }.pack();\n\n        let block_header = env.private().historical_header;\n        let address = env.contract_address();\n\n        // Mock the oracle to return a non-zero hint/packed value\n        let _ = OracleMock::mock(\"storageRead\")\n            .with_params((\n                address.to_field(), storage_slot, block_header.global_variables.block_number as u32,\n                value_packed.len(),\n            ))\n            .returns(value_packed)\n            .times(1);\n\n        // This should revert because the hint value is non-zero and the hash is zero (default value of storage)\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            block_header,\n            address,\n            storage_slot,\n        );\n    }\n\n    #[test(should_fail_with = \"Hint values do not match hash\")]\n    unconstrained fn test_bad_hint_initialized_value() {\n        let mut env = TestEnvironment::new();\n\n        let value_packed = MockStruct { a: 5, b: 3 }.pack();\n\n        // We write the value to storage\n        cheatcodes::direct_storage_write(env.contract_address(), storage_slot, value_packed);\n\n        // Now we write incorrect hash to the hash storage slot\n        let incorrect_hash = random();\n        let hash_storage_slot = storage_slot + (value_packed.len() as Field);\n        cheatcodes::direct_storage_write(\n            env.contract_address(),\n            hash_storage_slot,\n            [incorrect_hash],\n        );\n\n        // We advance block by 1 because env.private() currently returns context at latest_block - 1\n        env.advance_block_by(1);\n\n        let _ = WithHash::<MockStruct, _>::historical_public_storage_read(\n            env.private().historical_header,\n            env.contract_address(),\n            storage_slot,\n        );\n    }\n}\n"
     },
-    "252": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+    "251": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "253": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
+    "252": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/eth_address.nr",
       "source": "use crate::{\n    constants::ETH_ADDRESS_LENGTH,\n    traits::{Deserialize, Empty, Packable, Serialize, ToField},\n};\n\npub struct EthAddress {\n    inner: Field,\n}\n\nimpl Eq for EthAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for EthAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for EthAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn serialize(self: Self) -> [Field; ETH_ADDRESS_LENGTH] {\n        [self.inner]\n    }\n}\n\nimpl Deserialize<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn deserialize(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        EthAddress::from_field(fields[0])\n    }\n}\n\nimpl Packable<ETH_ADDRESS_LENGTH> for EthAddress {\n    fn pack(self) -> [Field; ETH_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; ETH_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl EthAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn from_field(field: Field) -> Self {\n        field.assert_max_bit_size::<160>();\n        Self { inner: field }\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "267": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
+    "266": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/data/public_data_tree_leaf_preimage.nr",
       "source": "use crate::{\n    data::public_data_tree_leaf::PublicDataTreeLeaf,\n    merkle_tree::leaf_preimage::{IndexedTreeLeafPreimage, LeafPreimage},\n    traits::{Empty, Hash},\n};\n\npub struct PublicDataTreeLeafPreimage {\n    pub slot: Field,\n    pub value: Field,\n    pub next_slot: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for PublicDataTreeLeafPreimage {\n    fn empty() -> Self {\n        Self { slot: 0, value: 0, next_slot: 0, next_index: 0 }\n    }\n}\n\nimpl Eq for PublicDataTreeLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.slot == other.slot)\n            & (self.value == other.value)\n            & (self.next_slot == other.next_slot)\n            & (self.next_index == other.next_index)\n    }\n}\n\nimpl Hash for PublicDataTreeLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash([\n                self.slot,\n                self.value,\n                (self.next_index as Field),\n                self.next_slot,\n            ])\n        }\n    }\n}\n\nimpl LeafPreimage for PublicDataTreeLeafPreimage {\n    fn get_key(self) -> Field {\n        self.slot\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl IndexedTreeLeafPreimage<PublicDataTreeLeaf> for PublicDataTreeLeafPreimage {\n    fn get_next_key(self) -> Field {\n        self.next_slot\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_slot == 0) & (self.next_index == 0)\n    }\n\n    fn update_pointers(self, next_slot: Field, next_index: u32) -> Self {\n        Self { slot: self.slot, value: self.value, next_slot, next_index }\n    }\n\n    fn update_value(self, write: PublicDataTreeLeaf) -> Self {\n        Self {\n            slot: self.slot,\n            value: write.value,\n            next_slot: self.next_slot,\n            next_index: self.next_index,\n        }\n    }\n\n    fn build_insertion_leaf(write: PublicDataTreeLeaf, low_leaf: Self) -> Self {\n        Self {\n            slot: write.slot,\n            value: write.value,\n            next_slot: low_leaf.next_slot,\n            next_index: low_leaf.next_index,\n        }\n    }\n}\n\nimpl PublicDataTreeLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.slot == 0) & (self.value == 0) & (self.next_slot == 0) & (self.next_index == 0)\n    }\n}\n"
     },
-    "268": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
+    "267": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "269": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+    "268": {
+      "path": "/mnt/user-data/grego/repos/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        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\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,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = 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_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [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\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> 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"
     },
-    "279": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
+    "278": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/root.nr",
       "source": "use crate::{hash::merkle_hash, merkle_tree::merkle_tree::MerkleTree};\n\n// Calculate the Merkle tree root from the sibling path and leaf.\n//\n// The leaf is hashed with its sibling, and then the result is hashed\n// with the next sibling etc in the path. The last hash is the root.\n//\n// TODO(David/Someone): The cpp code is using a uint256, whereas its\n// TODO a bit simpler in Noir to just have a bit array.\n// TODO: I'd generally like to avoid u256 for algorithms like\n// this because it means we never even need to consider cases where\n// the index is greater than p.\npub fn root_from_sibling_path<let N: u32>(\n    leaf: Field,\n    leaf_index: Field,\n    sibling_path: [Field; N],\n) -> Field {\n    let mut node = leaf;\n    let indices: [u1; N] = leaf_index.to_le_bits();\n\n    for i in 0..N {\n        let (hash_left, hash_right) = if indices[i] == 1 {\n            (sibling_path[i], node)\n        } else {\n            (node, sibling_path[i])\n        };\n        node = merkle_hash(hash_left, hash_right);\n    }\n    node\n}\n\npub fn calculate_subtree_root<let N: u32>(leaves: [Field; N]) -> Field {\n    MerkleTree::new(leaves).get_root()\n}\n\n// These values are precomputed and we run tests to ensure that they\n// are correct. The values themselves were computed from the cpp code.\n//\n// Would be good if we could use width since the compute_subtree\n// algorithm uses depth.\npub fn calculate_empty_tree_root(depth: u32) -> Field {\n    if depth == 0 {\n        0\n    } else if depth == 1 {\n        0x0b63a53787021a4a962a452c2921b3663aff1ffd8d5510540f8e659e782956f1\n    } else if depth == 2 {\n        0x0e34ac2c09f45a503d2908bcb12f1cbae5fa4065759c88d501c097506a8b2290\n    } else if depth == 3 {\n        0x21f9172d72fdcdafc312eee05cf5092980dda821da5b760a9fb8dbdf607c8a20\n    } else if depth == 4 {\n        0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e\n    } else if depth == 5 {\n        0x120157cfaaa49ce3da30f8b47879114977c24b266d58b0ac18b325d878aafddf\n    } else if depth == 6 {\n        0x01c28fe1059ae0237b72334700697bdf465e03df03986fe05200cadeda66bd76\n    } else if depth == 7 {\n        0x2d78ed82f93b61ba718b17c2dfe5b52375b4d37cbbed6f1fc98b47614b0cf21b\n    } else if depth == 8 {\n        0x067243231eddf4222f3911defbba7705aff06ed45960b27f6f91319196ef97e1\n    } else if depth == 9 {\n        0x1849b85f3c693693e732dfc4577217acc18295193bede09ce8b97ad910310972\n    } else if depth == 10 {\n        0x2a775ea761d20435b31fa2c33ff07663e24542ffb9e7b293dfce3042eb104686\n    } else {\n        panic(f\"depth should be between 0 and 10\")\n    }\n}\n\n#[test]\nfn test_merkle_root_interop_test() {\n    // This is a test to ensure that we match the cpp implementation.\n    // You can grep for `TEST_F(root_rollup_tests, noir_interop_test)`\n    // to find the test that matches this.\n    let root = calculate_subtree_root([1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);\n    assert(0x1a09d935ae110b4c861fcec8f9099ec30b4485022aeb3d3cf9d7168e38fdc231 == root);\n\n    let empty_root = calculate_subtree_root([0; 16]);\n    assert(0x2373ea368857ec7af97e7b470d705848e2bf93ed7bef142a490f2119bcf82d8e == empty_root);\n}\n\n#[test]\nfn test_empty_subroot() {\n    assert(calculate_empty_tree_root(0) == 0);\n\n    let expected_empty_root_2 = calculate_subtree_root([0; 2]);\n    assert(calculate_empty_tree_root(1) == expected_empty_root_2);\n\n    let expected_empty_root_4 = calculate_subtree_root([0; 4]);\n    assert(calculate_empty_tree_root(2) == expected_empty_root_4);\n\n    let expected_empty_root_8 = calculate_subtree_root([0; 8]);\n    assert(calculate_empty_tree_root(3) == expected_empty_root_8);\n\n    let expected_empty_root_16 = calculate_subtree_root([0; 16]);\n    assert(calculate_empty_tree_root(4) == expected_empty_root_16);\n\n    let expected_empty_root_32 = calculate_subtree_root([0; 32]);\n    assert(calculate_empty_tree_root(5) == expected_empty_root_32);\n\n    let expected_empty_root_64 = calculate_subtree_root([0; 64]);\n    assert(calculate_empty_tree_root(6) == expected_empty_root_64);\n\n    let expected_empty_root_128 = calculate_subtree_root([0; 128]);\n    assert(calculate_empty_tree_root(7) == expected_empty_root_128);\n\n    let expected_empty_root_256 = calculate_subtree_root([0; 256]);\n    assert(calculate_empty_tree_root(8) == expected_empty_root_256);\n\n    let expected_empty_root_512 = calculate_subtree_root([0; 512]);\n    assert(calculate_empty_tree_root(9) == expected_empty_root_512);\n\n    let expected_empty_root_1024 = calculate_subtree_root([0; 1024]);\n    assert(calculate_empty_tree_root(10) == expected_empty_root_1024);\n}\n"
     },
-    "286": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+    "285": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "298": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
+    "297": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "311": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
+    "310": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_packable, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for U128 {\n    fn empty() -> Self {\n        U128::from_integer(0)\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for U128 {\n    fn to_field(self) -> Field {\n        self.to_integer()\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    fn from_field(value: Field) -> Self {\n        value as bool\n    }\n}\nimpl FromField for u1 {\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for U128 {\n    fn from_field(value: Field) -> Self {\n        U128::from_integer(value)\n    }\n}\n\n// docs:start:serialize\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Type Parameters\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize<N> for str<N> {\n///     fn serialize(self) -> [Field; N] {\n///         let bytes = self.as_bytes();\n///         let mut fields = [0; N];\n///         for i in 0..bytes.len() {\n///             fields[i] = bytes[i] as Field;  // Each byte gets its own Field\n///         }\n///         fields\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// docs:start:deserialize\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Type Parameters\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Deserialize<N> for str<N> {\n///     fn deserialize(fields: [Field; N]) -> Self {\n///         str<N>::from(fields.map(|value| value as u8))\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    fn deserialize(fields: [Field; N]) -> Self {\n        str<N>::from(fields.map(|value| value as u8))\n    }\n}\n\n/// Trait for efficiently packing and unpacking Noir types into and from arrays of Fields.\n///\n/// The `Packable` trait allows types to be serialized and deserialized with a focus on minimizing the size of\n/// the resulting Field array. This trait is used when storage efficiency is critical (e.g. when storing data\n/// in the contract's public storage).\n///\n/// # Type Parameters\n/// * `N` - The length of the Field array, known at compile time.\n#[derive_via(derive_packable)]\npub trait Packable<let N: u32> {\n    /// Packs the current value into a compact array of `Field` elements.\n    fn pack(self) -> [Field; N];\n\n    /// Unpacks a compact array of `Field` elements into the original value.\n    fn unpack(fields: [Field; N]) -> Self;\n}\n"
     },
-    "315": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
+    "314": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
       "source": "use crate::traits::{Packable, ToField};\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable<BOOL_PACKED_LEN> for bool {\n    fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Packable<U8_PACKED_LEN> for u8 {\n    fn pack(self) -> [Field; U8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable<U16_PACKED_LEN> for u16 {\n    fn pack(self) -> [Field; U16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable<U32_PACKED_LEN> for u32 {\n    fn pack(self) -> [Field; U32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable<U64_PACKED_LEN> for u64 {\n    fn pack(self) -> [Field; U64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable<U128_PACKED_LEN> for U128 {\n    fn pack(self) -> [Field; U128_PACKED_LEN] {\n        [self.to_field()]\n    }\n\n    fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n        U128::from_integer(fields[0])\n    }\n}\n\nimpl Packable<FIELD_PACKED_LEN> for Field {\n    fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n        [self]\n    }\n\n    fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable<I8_PACKED_LEN> for i8 {\n    fn pack(self) -> [Field; I8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Packable<I16_PACKED_LEN> for i16 {\n    fn pack(self) -> [Field; I16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Packable<I32_PACKED_LEN> for i32 {\n    fn pack(self) -> [Field; I32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Packable<I64_PACKED_LEN> for i64 {\n    fn pack(self) -> [Field; I64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Packable<N * M> for [T; N]\nwhere\n    T: Packable<M>,\n{\n    fn pack(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].pack();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    fn unpack(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
     },
-    "316": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
-      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 2;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        // We use little-endian ordering to match the order in which U128 defines its limbs.\n        // This is necessary because of how Noir handles serialization:\n        // - When calling a contract function from TypeScript, the serialization in encoder.ts gets used and then Noir\n        //   deserializes using its intrinsic serialization logic (based on the limb order in the struct).\n        // - When calling a contract function from another function, the `serialize` method is invoked on the type\n        //   first.\n        // For this reason if we didn't use the ordering of U128 limbs here and in encoder.ts we would get an arguments\n        // hash mismatch.\n        [self.lo, self.hi]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_u64s_le(fields[0] as u64, fields[1] as u64)\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
+    "315": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
+      "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 2;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for U128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        // We use little-endian ordering to match the order in which U128 defines its limbs.\n        // This is necessary because of how Noir handles serialization:\n        // - When calling a contract function from TypeScript, the serialization in encoder.ts gets used and then Noir\n        //   deserializes using its intrinsic serialization logic (based on the limb order in the struct).\n        // - When calling a contract function from another function, the `serialize` method is invoked on the type\n        //   first.\n        // For this reason if we didn't use the ordering of U128 limbs here and in encoder.ts we would get an arguments\n        // hash mismatch.\n        // The below warning is due to visibility in noir stdlib.\n        [self.lo, self.hi]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for U128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        U128::from_u64s_le(fields[0] as u64, fields[1] as u64)\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "333": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
+    "332": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/field.nr",
       "source": "pub fn field_from_bytes<let N: u32>(bytes: [u8; N], big_endian: bool) -> Field {\n    assert(bytes.len() < 32, \"field_from_bytes: N must be less than 32\");\n    let mut as_field = 0;\n    let mut offset = 1;\n    for i in 0..N {\n        let mut index = i;\n        if big_endian {\n            index = N - i - 1;\n        }\n        as_field += (bytes[index] as Field) * offset;\n        offset *= 256;\n    }\n\n    as_field\n}\n\n// Convert a 32 byte array to a field element by truncating the final byte\npub fn field_from_bytes_32_trunc(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..15 {\n        // covers bytes 16..30 (31 is truncated and ignored)\n        low = low + (bytes32[15 + 15 - i] as Field) * v;\n        v = v * 256;\n        // covers bytes 0..14\n        high = high + (bytes32[14 - i] as Field) * v;\n    }\n    // covers byte 15\n    low = low + (bytes32[15] as Field) * v;\n\n    low + high * v\n}\n\n// TODO to radix returns u8, so we cannot use bigger radixes. It'd be ideal to use a radix of the maximum range-constrained integer noir supports\npub fn full_field_less_than(lhs: Field, rhs: Field) -> bool {\n    lhs.lt(rhs)\n}\n\npub fn full_field_greater_than(lhs: Field, rhs: Field) -> bool {\n    rhs.lt(lhs)\n}\n\npub fn min(f1: Field, f2: Field) -> Field {\n    if f1.lt(f2) {\n        f1\n    } else {\n        f2\n    }\n}\n\n#[test]\nunconstrained fn bytes_field_test() {\n    // Tests correctness of field_from_bytes_32_trunc against existing methods\n    // Bytes representing 0x543e0a6642ffeb8039296861765a53407bba62bd1c97ca43374de950bbe0a7\n    let inputs = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167,\n    ];\n    let field = field_from_bytes(inputs, true);\n    let return_bytes: [u8; 31] = field.to_be_bytes();\n    assert_eq(inputs, return_bytes);\n    // 32 bytes - we remove the final byte, and check it matches the field\n    let inputs2 = [\n        84, 62, 10, 102, 66, 255, 235, 128, 57, 41, 104, 97, 118, 90, 83, 64, 123, 186, 98, 189, 28,\n        151, 202, 67, 55, 77, 233, 80, 187, 224, 167, 158,\n    ];\n    let field2 = field_from_bytes_32_trunc(inputs2);\n    let return_bytes2: [u8; 31] = field.to_be_bytes();\n\n    assert_eq(return_bytes2, return_bytes);\n    assert_eq(field2, field);\n}\n\n#[test]\nunconstrained fn max_field_test() {\n    // Tests the hardcoded value in constants.nr vs underlying modulus\n    // NB: We can't use 0-1 in constants.nr as it will be transpiled incorrectly to ts and sol constants files\n    let max_value = crate::constants::MAX_FIELD_VALUE;\n    assert_eq(max_value, 0 - 1);\n    // modulus == 0 is tested elsewhere, so below is more of a sanity check\n    let max_bytes: [u8; 32] = max_value.to_be_bytes();\n    let mod_bytes = std::field::modulus_be_bytes();\n    for i in 0..31 {\n        assert_eq(max_bytes[i], mod_bytes[i]);\n    }\n    assert_eq(max_bytes[31], mod_bytes[31] - 1);\n}\n"
     },
-    "335": {
-      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+    "334": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "346": {
-      "path": "/root/nargo/github.com/noir-lang/sha256/v0.1.0/src/sha256.nr",
+    "345": {
+      "path": "/mnt/user-data/grego/nargo/github.com/noir-lang/sha256/v0.1.0/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\n"
     },
     "52": {
@@ -4434,27 +4434,27 @@
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Not, Rem, Shl, Shr, Sub};\nuse crate::static_assert;\nuse super::{convert::AsPrimitive, default::Default};\n\nglobal pow64: Field = 18446744073709551616; //2^64;\nglobal pow63: Field = 9223372036854775808; // 2^63;\npub struct U128 {\n    pub(crate) lo: Field,\n    pub(crate) hi: Field,\n}\n\nimpl U128 {\n\n    pub fn from_u64s_le(lo: u64, hi: u64) -> U128 {\n        // in order to handle multiplication, we need to represent the product of two u64 without overflow\n        assert(crate::field::modulus_num_bits() as u32 > 128);\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    pub fn from_u64s_be(hi: u64, lo: u64) -> U128 {\n        U128::from_u64s_le(lo, hi)\n    }\n\n    pub fn zero() -> U128 {\n        U128 { lo: 0, hi: 0 }\n    }\n\n    pub fn one() -> U128 {\n        U128 { lo: 1, hi: 0 }\n    }\n    pub fn from_le_bytes(bytes: [u8; 16]) -> U128 {\n        let mut lo = 0;\n        let mut base = 1;\n        for i in 0..8 {\n            lo += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        let mut hi = 0;\n        base = 1;\n        for i in 8..16 {\n            hi += (bytes[i] as Field) * base;\n            base *= 256;\n        }\n        U128 { lo, hi }\n    }\n\n    pub fn to_be_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_be_bytes();\n        let hi: [u8; 8] = self.hi.to_be_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = hi[i];\n            bytes[i + 8] = lo[i];\n        }\n        bytes\n    }\n\n    pub fn to_le_bytes(self: Self) -> [u8; 16] {\n        let lo: [u8; 8] = self.lo.to_le_bytes();\n        let hi: [u8; 8] = self.hi.to_le_bytes();\n        let mut bytes = [0; 16];\n        for i in 0..8 {\n            bytes[i] = lo[i];\n            bytes[i + 8] = hi[i];\n        }\n        bytes\n    }\n\n    pub fn from_hex<let N: u32>(hex: str<N>) -> U128 {\n        let bytes = hex.as_bytes();\n        // string must starts with \"0x\"\n        assert((bytes[0] == 48) & (bytes[1] == 120), \"Invalid hexadecimal string\");\n        static_assert(N < 35, \"Input does not fit into a U128\");\n\n        let mut lo = 0;\n        let mut hi = 0;\n        let mut base = 1;\n        if N <= 18 {\n            for i in 0..N - 2 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n        } else {\n            for i in 0..16 {\n                lo += U128::decode_ascii(bytes[N - i - 1]) * base;\n                base = base * 16;\n            }\n            base = 1;\n            for i in 17..N - 1 {\n                hi += U128::decode_ascii(bytes[N - i]) * base;\n                base = base * 16;\n            }\n        }\n        U128 { lo: lo as Field, hi: hi as Field }\n    }\n\n    unconstrained fn unconstrained_check_is_upper_ascii(ascii: u8) -> bool {\n        ((ascii >= 65) & (ascii <= 90)) // Between 'A' and 'Z'\n    }\n\n    pub(crate) fn decode_ascii(ascii: u8) -> Field {\n        (\n            if ascii < 58 {\n                ascii - 48\n            } else {\n                /// Safety: optionally adds 32 and then check (below) the result is in 'a..f' range\n                let ascii =\n                    ascii + 32 * (unsafe { U128::unconstrained_check_is_upper_ascii(ascii) as u8 });\n                assert(ascii >= 97); // enforce >= 'a'\n                assert(ascii <= 102); // enforce <= 'f'\n                ascii - 87\n            }\n        ) as Field\n    }\n\n    // TODO: Replace with a faster version.\n    // A circuit that uses this function can be slow to compute\n    // (we're doing up to 127 calls to compute the quotient)\n    unconstrained fn unconstrained_div(self: Self, b: U128) -> (U128, U128) {\n        if b == U128::zero() {\n            // Return 0,0 to avoid eternal loop\n            (U128::zero(), U128::zero())\n        } else if self < b {\n            (U128::zero(), self)\n        } else if self == b {\n            (U128::one(), U128::zero())\n        } else {\n            let (q, r) = if b.hi as u64 >= pow63 as u64 {\n                // The result of multiplication by 2 would overflow\n                (U128::zero(), self)\n            } else {\n                self.unconstrained_div(b * U128::from_u64s_le(2, 0))\n            };\n            let q_mul_2 = q * U128::from_u64s_le(2, 0);\n            if r < b {\n                (q_mul_2, r)\n            } else {\n                (q_mul_2 + U128::one(), r - b)\n            }\n        }\n    }\n\n    pub fn from_integer<T>(i: T) -> U128\n    where\n        T: AsPrimitive<Field>,\n    {\n        let f = i.as_();\n        // Reject values which would overflow a u128\n        f.assert_max_bit_size::<128>();\n        let lo = f as u64 as Field;\n        let hi = (f - lo) / pow64;\n        U128 { lo, hi }\n    }\n\n    pub fn to_integer<T>(self) -> T\n    where\n        Field: AsPrimitive<T>,\n    {\n        AsPrimitive::as_(self.lo + self.hi * pow64)\n    }\n\n    fn wrapping_mul(self: Self, b: U128) -> U128 {\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.lo * b.hi + self.hi * b.lo + carry;\n        let hi = high as u64 as Field;\n        U128 { lo, hi }\n    }\n}\n\nimpl Add for U128 {\n    fn add(self: Self, b: U128) -> U128 {\n        let low = self.lo + b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = self.hi + b.hi + carry;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to add with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Sub for U128 {\n    fn sub(self: Self, b: U128) -> U128 {\n        let low = pow64 + self.lo - b.lo;\n        let lo = low as u64 as Field;\n        let borrow = (low == lo) as Field;\n        let high = self.hi - b.hi - borrow;\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to subtract with underflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Mul for U128 {\n    fn mul(self: Self, b: U128) -> U128 {\n        assert(self.hi * b.hi == 0, \"attempt to multiply with overflow\");\n        let low = self.lo * b.lo;\n        let lo = low as u64 as Field;\n        let carry = (low - lo) / pow64;\n        let high = if crate::field::modulus_num_bits() as u32 > 196 {\n            (self.lo + self.hi) * (b.lo + b.hi) - low + carry\n        } else {\n            self.lo * b.hi + self.hi * b.lo + carry\n        };\n        let hi = high as u64 as Field;\n        assert(hi == high, \"attempt to multiply with overflow\");\n        U128 { lo, hi }\n    }\n}\n\nimpl Div for U128 {\n    fn div(self: Self, b: U128) -> U128 {\n        /// Safety: euclidian division is asserted to be correct: assert(a == b * q + r); and assert(r < b);\n        /// Furthermore, U128 addition and multiplication ensures that b * q + r does not overflow\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n            q\n        }\n    }\n}\n\nimpl Rem for U128 {\n    fn rem(self: Self, b: U128) -> U128 {\n        /// Safety: cf div() above\n        unsafe {\n            let (q, r) = self.unconstrained_div(b);\n            let a = b * q + r;\n            assert_eq(self, a);\n            assert(r < b);\n\n            r\n        }\n    }\n}\n\nimpl Eq for U128 {\n    fn eq(self: Self, b: U128) -> bool {\n        (self.lo == b.lo) & (self.hi == b.hi)\n    }\n}\n\nimpl Ord for U128 {\n    fn cmp(self, other: Self) -> Ordering {\n        let hi_ordering = (self.hi as u64).cmp((other.hi as u64));\n        let lo_ordering = (self.lo as u64).cmp((other.lo as u64));\n\n        if hi_ordering == Ordering::equal() {\n            lo_ordering\n        } else {\n            hi_ordering\n        }\n    }\n}\n\nimpl Not for U128 {\n    fn not(self) -> U128 {\n        U128 { lo: (!(self.lo as u64)) as Field, hi: (!(self.hi as u64)) as Field }\n    }\n}\n\nimpl BitOr for U128 {\n    fn bitor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) | (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) | (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitAnd for U128 {\n    fn bitand(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) & (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) & (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl BitXor for U128 {\n    fn bitxor(self, other: U128) -> U128 {\n        U128 {\n            lo: ((self.lo as u64) ^ (other.lo as u64)) as Field,\n            hi: ((self.hi as u64) ^ (other.hi as u64)) as Field,\n        }\n    }\n}\n\nimpl Shl for U128 {\n    fn shl(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift left with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self.wrapping_mul(U128::from_integer(y))\n    }\n}\n\nimpl Shr for U128 {\n    fn shr(self, other: u8) -> U128 {\n        assert(other < 128, \"attempt to shift right with overflow\");\n        let exp_bits: [u1; 7] = (other as Field).to_be_bits();\n\n        let mut r: Field = 2;\n        let mut y: Field = 1;\n        for i in 1..8 {\n            let bit = exp_bits[7 - i] as Field;\n            y = bit * (r * y) + (1 - bit) * y;\n            r *= r;\n        }\n        self / U128::from_integer(y)\n    }\n}\n\nimpl Default for U128 {\n    fn default() -> Self {\n        U128::zero()\n    }\n}\n\nmod tests {\n    use crate::default::Default;\n    use crate::ops::Not;\n    use crate::uint128::{pow63, pow64, U128};\n\n    #[test]\n    fn test_not(lo: u64, hi: u64) {\n        let num = U128::from_u64s_le(lo, hi);\n        let not_num = num.not();\n\n        assert_eq(not_num.hi, (hi.not() as Field));\n        assert_eq(not_num.lo, (lo.not() as Field));\n\n        let not_not_num = not_num.not();\n        assert_eq(num, not_not_num);\n    }\n    #[test]\n    fn test_construction() {\n        // Check little-endian u64 is inversed with big-endian u64 construction\n        let a = U128::from_u64s_le(2, 1);\n        let b = U128::from_u64s_be(1, 2);\n        assert_eq(a, b);\n        // Check byte construction is equivalent\n        let c = U128::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);\n        let d = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        assert_eq(c, d);\n    }\n    #[test]\n    fn test_byte_decomposition() {\n        let a = U128::from_u64s_le(0x0706050403020100, 0x0f0e0d0c0b0a0908);\n        // Get big-endian and little-endian byte decompostions\n        let le_bytes_a = a.to_le_bytes();\n        let be_bytes_a = a.to_be_bytes();\n\n        // Check equivalence\n        for i in 0..16 {\n            assert_eq(le_bytes_a[i], be_bytes_a[15 - i]);\n        }\n        // Reconstruct U128 from byte decomposition\n        let b = U128::from_le_bytes(le_bytes_a);\n        // Check that it's the same element\n        assert_eq(a, b);\n    }\n    #[test]\n    fn test_hex_constuction() {\n        let a = U128::from_u64s_le(0x1, 0x2);\n        let b = U128::from_hex(\"0x20000000000000001\");\n        assert_eq(a, b);\n\n        let c = U128::from_hex(\"0xffffffffffffffffffffffffffffffff\");\n        let d = U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff);\n        assert_eq(c, d);\n\n        let e = U128::from_hex(\"0x00000000000000000000000000000000\");\n        let f = U128::from_u64s_le(0, 0);\n        assert_eq(e, f);\n    }\n\n    // Ascii decode tests\n\n    #[test]\n    fn test_ascii_decode_correct_range() {\n        // '0'..'9' range\n        for i in 0..10 {\n            let decoded = U128::decode_ascii(48 + i);\n            assert_eq(decoded, i as Field);\n        }\n        // 'A'..'F' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(65 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n        // 'a'..'f' range\n        for i in 0..6 {\n            let decoded = U128::decode_ascii(97 + i);\n            assert_eq(decoded, (i + 10) as Field);\n        }\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_0() {\n        crate::println(U128::decode_ascii(0));\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_less_than_48_fails_1() {\n        crate::println(U128::decode_ascii(47));\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_0() {\n        let _ = U128::decode_ascii(58);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_58_64_fails_1() {\n        let _ = U128::decode_ascii(64);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_0() {\n        let _ = U128::decode_ascii(71);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_71_96_fails_1() {\n        let _ = U128::decode_ascii(96);\n    }\n    #[test(should_fail)]\n    fn test_ascii_decode_range_greater_than_102_fails() {\n        let _ = U128::decode_ascii(103);\n    }\n\n    #[test(should_fail)]\n    fn test_ascii_decode_regression() {\n        // This code will actually fail because of ascii_decode,\n        // but in the past it was possible to create a value > (1<<128)\n        let a = U128::from_hex(\"0x~fffffffffffffffffffffffffffffff\");\n        let b: Field = a.to_integer();\n        let c: [u8; 17] = b.to_le_bytes();\n        assert(c[16] != 0);\n    }\n\n    #[test]\n    fn test_unconstrained_div() {\n        // Test the potential overflow case\n        let a = U128::from_u64s_le(0x0, 0xffffffffffffffff);\n        let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);\n        let c = U128::one();\n        let d = U128::from_u64s_le(0x0, 0x1);\n        /// Safety: testing context\n        unsafe {\n            let (q, r) = a.unconstrained_div(b);\n            assert_eq(q, c);\n            assert_eq(r, d);\n        }\n\n        let a = U128::from_u64s_le(2, 0);\n        let b = U128::one();\n        // Check the case where a is a multiple of b\n        /// Safety: testing context\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (a, U128::zero()));\n        }\n\n        // Check where b is a multiple of a\n        /// Safety: testing context\n        unsafe {\n            let (c, d) = b.unconstrained_div(a);\n            assert_eq((c, d), (U128::zero(), b));\n        }\n\n        // Dividing by zero returns 0,0\n        let a = U128::from_u64s_le(0x1, 0x0);\n        let b = U128::zero();\n        /// Safety: testing context\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::zero(), U128::zero()));\n        }\n        // Dividing 1<<127 by 1<<127 (special case)\n        let a = U128::from_u64s_le(0x0, pow63 as u64);\n        let b = U128::from_u64s_le(0x0, pow63 as u64);\n        /// Safety: testing context\n        unsafe {\n            let (c, d) = a.unconstrained_div(b);\n            assert_eq((c, d), (U128::one(), U128::zero()));\n        }\n    }\n\n    #[test]\n    fn integer_conversions() {\n        // Maximum\n        let start: Field = 0xffffffffffffffffffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Minimum\n        let start: Field = 0x0;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // Low limb\n        let start: Field = 0xffffffffffffffff;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n\n        // High limb\n        let start: Field = 0xffffffffffffffff0000000000000000;\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn integer_conversions_fuzz(lo: u64, hi: u64) {\n        let start: Field = (lo as Field) + pow64 * (hi as Field);\n        let a = U128::from_integer(start);\n        let end = a.to_integer();\n        assert_eq(start, end);\n    }\n\n    #[test]\n    fn test_wrapping_mul() {\n        // 1*0==0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::one()));\n\n        // 0*1==0\n        assert_eq(U128::zero(), U128::one().wrapping_mul(U128::zero()));\n\n        // 1*1==1\n        assert_eq(U128::one(), U128::one().wrapping_mul(U128::one()));\n\n        // 0 * ( 1 << 64 ) ==  0\n        assert_eq(U128::zero(), U128::zero().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * 0 == 0\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::zero()));\n\n        // 1 * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::from_u64s_le(0, 1).wrapping_mul(U128::one()));\n\n        // ( 1 << 64 ) * 1 == 1 << 64\n        assert_eq(U128::from_u64s_le(0, 1), U128::one().wrapping_mul(U128::from_u64s_le(0, 1)));\n\n        // ( 1 << 64 ) * ( 1 << 64 ) == 1 << 64\n        assert_eq(U128::zero(), U128::from_u64s_le(0, 1).wrapping_mul(U128::from_u64s_le(0, 1)));\n        // -1 * -1 == 1\n        assert_eq(\n            U128::one(),\n            U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff).wrapping_mul(\n                U128::from_u64s_le(0xffffffffffffffff, 0xffffffffffffffff),\n            ),\n        );\n    }\n\n    #[test]\n    fn test_default() {\n        assert_eq(U128::default(), U128::zero());\n    }\n}\n"
     },
     "62": {
-      "path": "/build-volume/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-contracts/contracts/fee_juice_contract/src/lib.nr",
       "source": "use dep::aztec::context::PublicContext;\nuse dep::aztec::prelude::AztecAddress;\nuse dep::aztec::protocol_types::hash::sha256_to_field;\n\npub fn calculate_fee<TPublicContext>(context: PublicContext) -> Field {\n    context.transaction_fee()\n}\n\npub fn get_bridge_gas_msg_hash(owner: AztecAddress, amount: U128) -> Field {\n    let mut hash_bytes = [0; 68];\n    let recipient_bytes: [u8; 32] = owner.to_field().to_be_bytes();\n    let amount_bytes: [u8; 32] = amount.to_field().to_be_bytes();\n\n    // The purpose of including the following selector is to make the message unique to that specific call. Note that\n    // it has nothing to do with calling the function.\n    let selector = comptime { std::hash::keccak256(\"claim(bytes32,uint256)\".as_bytes(), 22) };\n\n    for i in 0..4 {\n        hash_bytes[i] = selector[i];\n    }\n\n    for i in 0..32 {\n        hash_bytes[i + 4] = recipient_bytes[i];\n        hash_bytes[i + 36] = amount_bytes[i];\n    }\n\n    let content_hash = sha256_to_field(hash_bytes);\n    content_hash\n}\n"
     },
     "63": {
-      "path": "/build-volume/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/noir-contracts/contracts/fee_juice_contract/src/main.nr",
       "source": "mod lib;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract FeeJuice {\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, view}, storage::storage},\n        protocol_types::address::{AztecAddress, EthAddress},\n        state_vars::{Map, PublicImmutable, PublicMutable},\n    };\n\n    use crate::lib::get_bridge_gas_msg_hash;\n\n    #[storage]\n    struct Storage<Context> {\n        // This map is accessed directly by protocol circuits to check balances for fee payment.\n        // Do not change this storage layout unless you also update the base rollup circuits.\n        balances: Map<AztecAddress, PublicMutable<U128, Context>, Context>,\n        portal_address: PublicImmutable<EthAddress, Context>,\n    }\n\n    // Not flagged as initializer to reduce cost of checking init nullifier in all functions.\n    // This function should be called as entrypoint to initialize the contract by minting itself funds.\n    #[private]\n    fn initialize(portal_address: EthAddress, initial_mint: U128) {\n        // Validate contract class parameters are correct\n        let self = context.this_address();\n\n        // Increase self balance and set as fee payer, and end setup\n        FeeJuice::at(self)._increase_public_balance(self, initial_mint).enqueue(&mut context);\n        context.set_as_fee_payer();\n        context.end_setup();\n\n        // Enqueue call to set the portal address\n        FeeJuice::at(self).set_portal(portal_address).enqueue(&mut context);\n    }\n\n    // We purposefully not set this function as an initializer so we do not bind\n    // the contract to a specific L1 portal address, since the Fee Juice address\n    // is a hardcoded constant in the rollup circuits.\n    #[public]\n    fn set_portal(portal_address: EthAddress) {\n        assert(storage.portal_address.read().is_zero());\n        storage.portal_address.initialize(portal_address);\n    }\n\n    #[private]\n    fn claim(to: AztecAddress, amount: U128, secret: Field, message_leaf_index: Field) {\n        let content_hash = get_bridge_gas_msg_hash(to, amount);\n        let portal_address = storage.portal_address.read();\n        assert(!portal_address.is_zero());\n\n        // Consume message and emit nullifier\n        context.consume_l1_to_l2_message(content_hash, secret, portal_address, message_leaf_index);\n\n        // TODO(palla/gas) Emit an unencrypted log to announce which L1 to L2 message has been claimed\n        // Otherwise, we cannot trace L1 deposits to their corresponding claims on L2\n        FeeJuice::at(context.this_address())._increase_public_balance(to, amount).enqueue(\n            &mut context,\n        );\n    }\n\n    #[public]\n    #[internal]\n    fn _increase_public_balance(to: AztecAddress, amount: U128) {\n        let new_balance = storage.balances.at(to).read().add(amount);\n        storage.balances.at(to).write(new_balance);\n    }\n\n    #[public]\n    #[view]\n    fn check_balance(fee_limit: U128) {\n        assert(storage.balances.at(context.msg_sender()).read() >= fee_limit, \"Balance too low\");\n    }\n\n    // utility function for testing\n    #[public]\n    #[view]\n    fn balance_of_public(owner: AztecAddress) -> pub U128 {\n        storage.balances.at(owner).read()\n    }\n}\n"
     },
-    "73": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
+    "74": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, traits::Deserialize,\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::hash_args;\nuse crate::oracle::execution_cache;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\npub struct PrivateCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args_hash: Field,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub gas_opts: GasOpts,\n    pub return_type: T,\n    pub is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicVoidCallInterface<let N: u32> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: (),\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    pub target_contract: AztecAddress,\n    pub selector: FunctionSelector,\n    pub name: str<N>,\n    pub args: [Field],\n    pub return_type: T,\n    pub is_static: bool,\n    pub gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (),\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let args_hash = hash_args(self.args);\n        execution_cache::store(self.args);\n        context.call_public_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            args_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n"
     },
-    "80": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
+    "81": {
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            /// Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            /// for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        /// Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        /// execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        /// the number of side effects that took place), along with the hash of the return values. We validate these\n        /// by requesting a private kernel iteration in which the return values are constrained to hash\n        /// to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "81": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
+    "82": {
+      "path": "/mnt/user-data/grego/repos/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, Packable, Serialize};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_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 args = args.push_front(function_selector.to_field());\n        let success = call(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let args = args.push_front(function_selector.to_field());\n        let success = call_static(gas_for_call(gas_opts), contract_address, args);\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        /// 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]) -> bool {\n    call_opcode(gas, address, args)\n}\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) -> bool {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// 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) -> bool {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
     "96": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "path": "/mnt/user-data/grego/repos/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }