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

package/artifacts/AuthRegistry.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
+  "noir_version": "1.0.0-beta.4+0000000000000000000000000000000000000000",
   "name": "AuthRegistry",
   "functions": [
     {
@@ -1604,9 +1604,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "16761564377371454734": {
+          "14225679739041873922": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Index out of bounds"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -1614,8 +1614,8 @@
           }
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+2dB3gUVduGJ7tJIKGE3kvohLqzJbtLb0novYPKJtlINICUIFhjr9h7BSwo9opd7IpdsTdU7L13/J/3Y8ecDJOo5Ezg+WWu67522s7c75mZM+3MOUnG9i7sNYw63u39ScCb+PWATNs461ftT3GYr47DuHoO4zIcxjV0GNcMDLGNa+8wX6bDuA4O4zo6jOvmMK5H4lftrOEhid+ALzsYjIf9cTNgxnz+aH4k5AuG8rMjZsQMRUKF/kggEI8EI+FofjTsi5rBQNwsCkUDRb7t3Z+e8mX5qtX5C9z0lETZSc+gfYS4NQLJiqukw7ZEf3ejvD9L6ReHber/MOwBXpDsLR9vdV5bGviq15k9NC4ryatv26R4tXk5bpsUb/k28Cj9XqU/2bZtUjFcC9QGaQ7bxqN523TTuK+nezVuZ6M8P5HlZtrSQfdxWkebu7/QaV+oo2xz6f7aL4zKj9O6GK4H6oOMGjhOUzVuv7oaj9MGLh+nDZRtU0/pr6/0Z9i2TUMMNwKNQROHbaN7/2yqMQ3c9Gy2855++4i/O981VLZPU6W/mW1bNcdwC9AStEpsK2ua16i8G6InvU3r2q+qdPdVrzMb1tD+4ateZzZ3wzPZKL+oNlxO6O6GOwmta6crCIcjwagZptuILnime3fvbWV5epRltk7kSG3sd4+tHa6CdF8NttZ41m7r0tVg20Q6JCfit+esbuxIbTRfgViOVn87K7iqTnft/uHprr0kEOgAOtbALUQbjTtNe5KcpZ2GmGMRfyjgj8Sr8qxuenbSd1tT5KZn5533DNhHOB1HnbzOj0nUS8jOtuOoC4a7gm6gu3LZ6DVqJtPp4vLZS3tG0FZjRpDl0tkjqwaeJfTQd9Dlu+nZU4NnthnNzs4PF7jp2WvnPUP2EU6ZQw8lE+hZSUbRy5Y59MZwH9AX+Grg2UyWxmX11nicmi5lUrvzM+g+GtPP7/KzLVPZn/1Kf1+l32fbtwMYDoIQyFZOfMlGjTwvCSYZOx5PutZhz68YHg/odswicOxhuJOv6PYMsF2kZWnMvMIuXaSFlVv8FMM5M9C9IZOM//YOpz2TIfH0GjV8AFe7RIHG4Hu6FLzumDUenGYvkpg9GmPuTRKzxoPR7FNDMfuq15l9NaZfKkmm6zM4PE0STz+JZ4DEM0jiGSLxzCbxDJN4Rkg8oySe/Ug8+5N4DiDxHEjiOYjEczCJ5xASz6EknsNIPIeTeI4g8cwh8cwl8cwj8RxJ4jmKxHM0iecYEs+xJJ7jSDzHk3hOIPGcSOI5icRzMonnFBLPqSSe00g8p5N4ziDxnEniOYvEczaJ5xwSz7kknnuReO5N4rkPiec8Es8YiWc+iWcBiWchiWecxLOIxHNfEs/5JJ7FJJ77kXjuT+JZQuK5gMRzIYnnIhLPA0g8F5N4LiHxXEriuYzEs5TEczmJ54EknitIPFeSeB5E4nkwiechJJ6HkngeRuJ5OIlnGYnnESSeR5J4HkXieTSJ5zEknseSeB5H4nk8iecJJJ4nknieROJ5MonnKhLPU0g8TyXxPI3E83QSzzNIPM8k8TyLxPNsEs9zSDzPJfE8j8TzfBLPC0g8LyTxvIjE82ISz0tIPC8l8VxN4rmGxHMtiedlJJ6Xk3heQeJ5JYnnOhLPq0g8rybxXE/ieQ2J57UknteReF5P4nkDieeNJJ43kXjeTOJ5C4nnrSSet5F43k7iuYHE8w4SzztJPO8i8bybxPMeEs97STzvI/G8n8RzI4nnAySeD5J4PkTi+TCJ5yMkno+SeD5G4vk4iecTJJ6bSDyfJPF8isTzaRLPZ0g8nyXxfI7E83kSzxdIPF8k8dxM4vkSiefLJJ6vkHi+SuL5Gonn6ySeb5B4vkni+RaJ59sknu+QeG4h8XyXxPM9Es/3STy3uuTp0ez5gbKs6rbd28XLEfOHGmNuS9Je8UcGh+fHJJ6fkHh+SuL5GYnn5ySeX5B4fkni+RWJ59cknt+QeH5L4vkdief3JJ4/kHj+SOL5E4nnzySev5B4/kri+RuJ5+8knn+QeG4j8fyTxFMWyOCZROLpIfH0kngmk3imkHimknjWIvGsTeKZRuKZTuJZh8SzLolnPRLP+iSeGSSeDUg8G5J4NiLxbEzi2cQlT/s78uq+107SGHNTkpi7a4y5Gcn+2Dyp+unnj0TC+dnxmJueLZL0beeq9iFf9TqzpUbP5iTlaVppjLkNScytNcacThJzG40xtyYpN9WWJB9vR+LZnsQzk8SzA4lnRxLPTiSenUk8u5B4diXx7Ebi2Z3EM4vEsweJZ08Sz14knr1JPPuQePYl8fSReJoknn4SzwCJZ5DEM0TimU3iGSbxjJB4Rkk8+5F49ifxHPAffA848D8Y8yCSmL0aYx5cQzH7qteZQzS+zwiQvMMZqjHmLJJ3OMNIzgnDSTxHkHjmkHjmknjmkXiOJPEcReI5msRzDInnWBLPcSSe40k8J5B4TiTxnETiOZnEcwqJ51QSz2kkntNJPGeQeM4k8ZxF4jmbxHMOiedcEs+9SDz3JvHch8RzHolnjMQzn8SzgMSzkMQzTuJZROK5L4nnfBLPYhLP/Ug89yfxLCHxXEDiuZDEcxGJ5wEknotJPJeQeC4l8VxG4llK4rmcxPNAEs8VJJ4rSTwPIvE8mMTzEBLPQ0k8DyPxPJzEs4zE8wgSzyNJPI8i8TyaxPMYEs9jSTyPI/E8nsTzBBLPE0k8TyLxPJnEcxWJ5ykknqeSeJ5G4nk6iecZJJ5nknieReJ5NonnOSSe55J4nkfieT6J5wUknheSeF5E4nkxieclJJ6XkniuJvFcQ+K5lsTzMhLPy0k8ryDxvJLEcx2J51UknleTeK4n8byGxPNaEs/rSDyvJ/G8gcTzRhLPm0g8bybxvIXE81YSz9tIPG8n8dxA4nkHieedJJ53kXjeTeJ5D4nnvSSe95F43k/iuZHE8wESzwdJPB8i8XyYxPMREs9HSTwfI/F8nMTzCRLPTSSeT5J4PkXi+TSJ5zMkns+SeD5H4vk8iecLJJ4vknhuJvF8icTzZRLPV0g8XyXxfI3E83USzzdIPN8k8XyLxPNtEs93SDy3kHi+S+L5Honn+ySeW0k8PyDx/JDE8yMSz49JPD8h8fyUxPMzEs/PSTy/IPH8ksTzKxLPr0k8vyHx/JbE8zsSz+9JPH8g8fyRxPMnEs+fSTx/IfH8lcTzNxLP30k8/yDx3Ebi+SeJp+Hh8Ewi8fSQeHpJPJNJPFNIPFNJPGuReNYm8Uwj8Uwn8axD4lmXxLMeiWd9Es8MEs8GJJ4NSTwbkXg2JvFsQuLZlMSzGYlncxLPFiSeLUk8W5F4tibxbEPi2ZbEsx2JZ3sSz0wSzw4knh1JPDuReHYm8exC4tmVxLMbiWd3Es8sEs8eJJ49STx7kXj2JvHsQ+LZl8TTR+Jpknj6STwDJJ5BEs8QiWc2iWeYxDNC4hkl8exH4tmfxHMAiedAEs9BJJ6DSTyHkHgOJfEcRuI5nMRzBIlnDolnLolnHonnSBLPUSSeo0k8x5B4jiXxHEfiOZ7EcwKJ50QSz0kknpNJPKeQeE4l8ZxG4jmdxHMGiedMEs9ZJJ6zSTznkHjOJfHci8RzbxLPfUg855F4xkg880k8C0g8C0k84ySeRSSe+5J4zifxLCbx3I/Ec38SzxISzwUkngtJPBeReB5A4rmYxHMJiedSEs9lJJ6lJJ7LSTwPJPFcQeK5ksTzIBLPg0k8DyHxPJTE8zASz8NJPMtIPI8g8TySxPMoEs+jSTyPIfE8lsTzOBLP40k8TyDxPJHE8yQSz5NJPFeReJ5C4nkqiedpJJ6nk3ieQeJ5JonnWSSeZ5N4nkPieS6J53kknueTeF5A4nkhiedFJJ4Xk3heQuJ5KYnnahLPNSSea0k8LyPxvJzE8woSzytJPNeReF5F4nk1ied6Es9rSDyvJfG8jsTzehLPG0g8byTxvInE82YSz1tIPG8l8byNxPN2Es8NJJ53kHjeSeJ5F4nn3SSe95B43kvieR+J5/0knhtJPB8g8XyQxPMhEs+HSTwfIfF8lMTzMRLPx0k8nyDx3ETi+SSJ51Mknk+TeD5D4vksiedzJJ7Pk3i+QOL5IonnZhLPl0g8XybxfIXE81USz9dc8vTYPAO+7GAwHvbHzYAZ8/mj+ZGQLxjKz46YETMUCRX6I4FAPBKMhKP50bAvagYDcbMoFA0UJZbdTWPMr9dQzL7qdeYbHn3pF/ZybOdkjen3Jsm+naIx5rdIYk7VGPPbJDHX0hjzOyQx19YY8xaSmNM0xvwuSczpGmN+jyTmOhpjfp8k5roaY95KEnM9jTF/QBJzfY0xf0gSc4bGmD8iibmBxpg/Jom5ocaYPyGJuZHGmD8libmxxpg/I4m5icaYPyeJuanGmL8gibmZxpi/JIm5ucaYvyKJuYXGmL8mibmlxpi/IYm5lcaYvyWJubXGmL8jibmNxpi/J4m5rcaYfyCJuZ3GmH8kibm9xph/Iok5U2PMP5PE3EFjzL+QxNxRY8y/ksTcSWPMv5HE3FljzL+TxNxFY8x/kMTcVWPM2zTG7DW2l/HZnAi4J+gFeoM+oK+sA5jAL+kAgiAEskEYREAU9AP9wQAwEAwCgxNxDwXDwHAwAuSAXJAHRoJRYDQYA8aCcWA8mAAmgklgMpgCpoJpYDqYAWaCWWA2mAPmgr3A3mAfMA/EQD4oAIUgDorAvmA+KAb7gf1BCVgAFoJF4ACwGCwBS8EyUAqWgwPBCrASHAQOBoeAQ8Fh4HBQBo4AR4KjwNHgGHAsOA4cD04AJ4KTwMlgFTgFnApOA6eDM8CZ4CxwNjgHnAvOA+eDC8CF4CJwMbgEXApWgzVgLbgMXA6uAFeCdeAqcDVYD64B14LrwPXgBnAjuAncDG4Bt4LbwO1gA7gD3AnuAneDe8C94D5wP9gIHgAPgofAw+AR8Ch4DDwOngCbwJPgKfA0eAY8C54Dz4MXwItgM3gJvAxeAa+C18Dr4A3wJngLvA3eAVvAu+A98D7YCj4AH4KPwMfgE/Ap+Ax8Dr4AX4KvwNfgG/At+A58D34AP4KfwM/gF/Ar+A38Dv4A28CfQA6wJOABXpAMUkAqqAVqgzSQDuqAuqAeqA8yQAPQEDQCjUET0BQ0A81BC9AStAKtQRvQFrQD7UEm6AA6gk6gM+gCuoJuoDvIAj1AT9AL9AZ9QF/gAybwgwAIghDIBmEQAVHQD/QHA8BAMAgMBkPAUDAMDAcjQA7IBXlgJBgFRoMxYCwYB8aDCWAimAQmgylgKpgGpoMZYCaYBWaDOWAu2AvsDfYB80AM5IMCUAjioAjsC+aDYrAf2B+UgAVgIVgEDgCLwRKwFCwDpWA5OBCsACvBQeBgcAg4FBwGDgdl4AhwJDgKHA2OAceC48Dx4ARwIjgJnAxWgVPAqeA0cDo4A5wJzgJng3PAueA8cD64AFwILgIXg0vApWA1WAPWgsvA5eAKcCVYB64CV4P14BpwLbgOXA9uADeCm8DN4BZwK7gN3A42gDvAneAucDe4B9wL7gP3g43gAfAgeAg8DB4Bj4LHwOPgCbAJPAmeAk+DZ8Cz4DnwPHgBvAg2g5fAy+AV8Cp4DbwO3gBvgrfA2+AdsAW8C94D74Ot4APwIfgIfAw+AZ+Cz8Dn4AvwJfgKfA2+Ad+C78D34AfwI/gJ/Ax+Ab+C38Dv4A+wDfwJ5GIiCXiAFySDFJAKaoHaIA2kgzqgLqgH6oMM0AA0BI1AY9AENAXNQHPQArQErUBr0Aa0Be1Ae5AJOoCOoBPoDLqArqAb6A6yQA/QE/QCvUEf0Bf4gAn8IACCIASyQRhEQBT0A/3BADAQDAKD5VoFDAXDwHAwAuSAXJAHRoJRYDQYA8aCcWA8mAAmgklgMpgCpoJpYDqYAWaCWWA2mAOkrXlpx13aSJf2x+cBaTdb2qSW9p6lLWVpp1jaAJb2daXtWmkXVtpclfZMpa1QaYdT2riU9iOlbUZp91DaFJT2+qQtPGlnTtpwk/bRpO0xaddL2syS9qikrSdpR0naKJL2f8qAtFsjbcJIeyvSlom0EyJtcEj7FtJ2hLTLIG0eSHsCUle/1IMvdcxL/e1SN7rUOy51ekt92VIXtdTzLHUoS/3EUvev1KsrddZKfbBS16rUYyp1hEr9m6uB1BspdTJKfYdSl6DU0yd14En9clJ3m9SLJnWOSX1eUleW1EMldTxJ/UlSN5HU+yN16kh9NVIXjNSzInWYSP0gUveG1GshdUZIfQxS14HUIyDf6Mv37xuBfLct30TL98byLa98JyvfoMr3nfLtpHyXKN/8yfd08q2afAcm31jJ90vybZB8dyPftMj3InKtKt85yDcEUj5fyr5LuXIpZy1lmKUcrpRLlXKaUm5xC5BybVLOS8o9STkgKRcj5USk3ISUI5D36vKeWd67yntIeS8n76nkvY28x5Dn+vKcW577ynNQeS4oz8nkuZE8R5HnCnKfLfedch8m9yVyne7Zfvo3pJyxdD2N8i6RNRjexHQplyvlVKXcppRjlHJ9Us5Nyn1JOSgpFyTlZKTciJSjkHIF8p5d3jvLe1h5Lynv6eS9lbzHkfca8pxfnnvLc2B5LirPCeW5WSboADoCue+W+1C5L5P7FCn73h1kgR7Gjl2K0t8k8dt069CWizety1Hny6xiWufE74Yha9ZmrV81Qp3Wo4r/BSuZlpr4jSZ+0xK/nsSvpLWk85DEsK96nZmmLFf38iO+YDjNqNhp9g+kGRX3S7eWn+LO8v9Xtlm6EWXly1djsdbrtc1n/49Mr5foTzJ2nMeKw439CNs55HI6mdbya7m0na10S1XSzusQk7X+erZtZU13+rWWZZ9mrSvdcHUfNquKTfW39o0GtvntaVDZslL/5bJ25TZV01rdpv+bp6x8msc2LVmZlmqbllK2Y4xy/stU5rMfg8m2adZ+Il1uWfkyeirL65Xot9LPzbzbrTxDusYO/uq6pKtVVp4eVtp4lXFWmlvboLY6v21amjItuazietITw8nKetRlWR4ptvmtc3xG4jdV+Y/1/wYO60+1rb+Ct8M4e7qkOcyf5jC/7KOdEv11Esg+FFCWV9kx4jF2XF6GsWN+YP3X5ePZb7kmO7iq+Yu1frnWbJroX7ps0ZL4qIU5K+IFpcuKFy0cHiuYHzdsnXrwqTum/eJXTQA1UKdleJX/O3WyQayLpOSyiv8bkhjvq0YXjvh81rqtAyLF5mnY1p9imz+SGE5X4rJ+q/PhYVE4ZhYFYkWxUKywMFgQa2RbvmGU73iSTnMT/eQXxfk1dVGc6s7yQy4f6I4XxU4HuLUP55SVp2VOWUUna548ZZ68SuYZqcwzUplHuqouru0ndtWjqhO700Vknm2ams9YTpKBWxmb9DdTHKUbVVbunmSbNlqZZvmm2Rw17+9Rl2/S/I0d/K11WSe8gUbFdFVPeH+dVA33L0jV9RmG842Btf50w9Xj+K8bg1o2n8ou5uWE2jjRXxArKZm4pHh5bFk8t3RhgZxT1RDUxXocQrSfDq157KfVJNuwxzZsP93a78dSHJZb2f/t46x1Zxg7Xqem2hztm9Q+rqr7oaqymKRKfq31GH+zHidnp+xqZ9fjZtYhXQObq7oul7OVkFMWbNjSsKrtqGYj9mPAcEhfQ5nHikmyruHKcu3z2X3U7ZCqLF+Nw2l7Od0Xp9gcK8tirfEuPwPKdsq67fGraW7fHrWVaf92e6j38/9me1T2nMF+bHpt05yeETDcKgxLDO/qWwX1lJ9h7Ljv2vN2dTvZ8zaXTr9++3nSSmu7T6oyXZ1/dOJXYp1ui83pft7rkFZ2B3V+Ne5kW3o5PRN1Ob2qvFxxSi9rfuu4TzWqfv6XYpt/cuJXhmcl+p3Oq17bNI/Dsp2OeSsNZX/VfbzEI9FCX7QoHjNN01/oi//d8aJ7/cFQLFwQC5tmNGjGg2bo79bfJ9FPfmufXVO39m6mj9P1gablO97aO13bVXW7LcejdRsi/U2U/6vLM4yqr8Vdvu0NuXx9av7b9xVe27QUZZp6vdnWlj5uvzN0aV8zGxuV71/WNUJ3JU3s+06SLR1c8vQn2dZnGM6PBaxx6S5uF59ynvXafOzpoz4WsB5BlSyKFeYuWbSg4oN2NYqkSqJTp6udU+okVTJeOqczrXqmscbv7m+WuiWGd+c3S5mJfoY7k96J4V19Z2IdKeRXOqE9VzpVd7qudOoa5f1/5TeG813IEI3b1sW0r/LNv3VmtvI29eyycNGy4qKVw5fE8dS5cHxpSUlxUXF8iWHr/umZgiHXsl7z7Opc6/9JecQYeXnE7D3lEf++q4HyiME95RF3uttTHrGKuO3b9H/zlJVPq+r+3u3yiFaxgl1UHjG2pzxi+fyV3TXuKY+4pzxihQPX6zDeY1Q8GajdnvKI//yiuHWin/yiOFJTF8VuX4y59OLR8aLYKcOx9uHcsvK0zC2r6GTNk6fMk6fMI11NlzWUDLihUd5v7fcun9Aju8NjBitDlsw5M9G//TFDzsLFpfHSeOHE0vyS4gKrkNvwWEmJYevsF91JtmH7SwV7npzssBx7p/4vSYlhd8+rWyWGd3Ve/X+2DjEbu1MCAA==",
-      "debug_symbols": "7VvbbuM4DP2XPPtBvIgi+yuLYtBLZhAgSIu0XWBR5N9Xzo5kN5XtFZq0mcYvgeXwyOI5kkxK8uvifnn78uvHavPz4Wlx9dfrYv1wd/O8etjE0usCeH/v6fFm0xafnm+2z4sr9ByaxXJzHy8FcNcsfq7Wy8UVYNg1762RXbJG6axNC8bkzP82JhAdNwZvkBoSr8llc1RfshevyVxCyNbksGRNQsmawb2xvm4W4GdqhqiRmZohasKZU+O5o6ZnXqYGASW1BNh/kBqdqRmixorUsEJHDU1QwyD225rRdQ0K+yegO/kToPQEChlDipIxnossKWcNyLRnLiVzE0gCx2vFcXPFbK3ocULfYJysgxlNWJOXjpnOlotd2DBxTj0WscwIYCaEYMLYQeIaXL8D814fnPU5a31o1ud/6RMyixiIJigPIVUMwfyH9OFZn7PWxx9BH8tjH9h5ndCH1eUGsbZVTph3gSZrsP4LtMCj+hzqxIB2PHq5dO1l1v5itQ+z9hervZ6/9tqZG+q49hRSR+FeMAn+vwTLzt5Zo66j21RHB5HcHWN6LnCQUJK7MH/hm/mrjtJMFq99OPQXL8xf+lJ/vetNKUXzkCf8oL2Jaj/TEp954+ObML0IWfqNn9+wH3nDkj933cGVdW8b//lpgXcsXeMD9c3bFn1+sOrJILeIeWIRAV1c+00dzeHUFHnpo0NnOb+TnDbL+Y3k5M9PIKKE2skZ3Li5ECbGhcRNhZc+72qb66IWENo7C+fuLOf2CweeWAQBxVQ3tp4fxNKMF+VtOXNQSiOFrJdNlr2N1eahAtrbS5Di6I5dM9UdAMZD5C89cME8czPIjZ+5GeRGZm4GuQnnzs3XHdVhnbkZ5MZmboa48e4Y3HQRCxjZBDdjmwkejtAc404qMxlvTrQIeXnUTMPHYiKPf7oD9NkOoHPd0SaH7McdMJ93K6C3cRWXtXbXsXS7Xa3Xq18/3pwnd+1POezwlBJdH+SwO5bfxuOQUA/ReohVQmIJWsvycS6hpJf2jpbFJc/hE0bjEF8PkXpIqIdoPaRItWKGsB5CyluE4xCoh2A9hOohXA/x9RCph4R6iNZDyupremGr2RtIKRbIp717CXe7rnI9tBZ0vOrhtNXjaaun01bPp63en7Z6OW314YjVK72rXk9bvZ20+nLQbDksNwqH80g5sB2HYD2E6iFcD/H1EKmHhGqIaD3EqiFh4JuV1GFQwmGHCVAPwXoI1UO4HuLrIVIPKX+wFvI2k70blUHrIVYNUVcPgXoI1kOoEhJLuE8Jis0Tn3IyMXeYfpQ/2hmHUD2E6yG+HiKVkFii1nLgI2WFnF5rb/Nsvx8WSzynonFu3/NXBHLIxCPv3mb3sfj3zXZ1c7tetml9++/L5i5l+bH4/M9j+ietAzxuH+6W9y/bZbsi0C0GtL0xrtExRg+gHdIeGi85Td7fEmhE2v/bAaLWGOQx08Jj2kCW4Owa9l3XaG+BNAhZ8uEH+oxAaDDe2kVX/wU=",
+      "bytecode": "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",
+      "debug_symbols": "7VvZbuM4EPwXP/uBfbCP/MpiMMjhGRgIkiDHAosg/76UMaQUh5KWSJx4Y70Ypl1Fs6sosZuUn1dXm4un3z+3N79uH1Znfz2vrm8vzx+3tzep9bwC3n32cHd+0zUfHs/vH1dnGFnXq83NVXorgC/r1a/t9WZ1BoFf1m/RyCGjUXq0xgqYgsc/YAKxaTBEhzyQ9J5CgaNZDS/RMlxUC5pCtXcSymiG8Ar9Y72CuEgzJo0s0oxJo0cuTeRemgG8Lg0CSh4JcHynNLZIMyaNV6Vhg14ampGGQfwPmjH0A0qRpF/AcPBfgNovkBYOGUrhxFBVybh4QG4DONbgLpANTu8Np+GGBW0YccZfdc5odacZNGmelkzcY2tBIkGeCkgDRbCuCJV5Q8MxV8GhXBwQzIfgzh9c/Dlqf2jx5z/5o/0SoHEGDOolFTCQd/nDiz9H7U/8AH/csSzTIdqMP2zBC9wGsY7B+0STTX24gFZ0tFh0TAntdPZy6t7L4v3Jeq+L9yfrvR2/99bDHW3ae1IrkkNfjbHugvWjD9apn+g+N9FBpEzHVJ4L7BWUFE4sXvhm8Vqgcu1aiLofL55YvPSl8cYwuKVU4RrzjpbaYLdsd6clPvLBp5UwL4Qsw8EvK+x7VliKx+47hLrv3eA/vyyIgaUfvNIQ3o3o85PVSA5lRMwzmwgYAMt+fMC5W+SpXx222Pmd7PTFzm9kJ39+AZEstN5ODdNwIcyKC0mYSy9jEcZDn7VA3GWXDMceLJfxCyvPbIKAYe4bu8j3cmnGk4q2XjkY5VSDfFBN1qNN3ZasCmxwltAx3/adpmbuWwGmU+QvfeCCedFmVJu4aDOqjSzajGqjx67N1z2qw7ZoM6qNL9qMaRPDR2jTZyzg5DPaTB0mRPiA4Tj3VrnL9HASopQM6b3p+3KiiP/3AOizA8AQyvxJ1SPH6QA8ltMKGBxcdVfCj9S6uN9eX29//3z1PHnoXuppR6Rc6EaV/elYX42nKdpOsXaKN1JSCzpk/XEuoeyXDR6gBKbxJ4ymKbGdIu0UbadYO6UqtWGhsO1T6keE0xRop2A7hdop3E6J7RRpp2g7xdopdfctL9jm/opSywXK096DgjutyuN7QR/XPRy2ezxs93TY7vmw3cfDdi+H7V4/sHujN93bYbv3g3ZfT5q9pOVOun8fqSe20xRsp1A7hdspsZ0i7RRtpoi1U7yZou3ua7v72u6+truv7e5r/Q+I5ZAGRfevF5V2irZT6n/k0nIy5W8uZPVmioV2CrRTsJ1C7RRupKQW7qqIakQScxknHvYrlvr/fKYp1E7hdkpsp0gjJbWoQ478r9mgVOQ2OG/bHaGlFi/Va1oOdvpViaxFeOSX1xsCqfn3+f32/OJ60+0EdN8+3VzmjYHUfPznLn+Ttw7u7m8vN1dP95tuE6HfP+hmY9rWY0wRQHcXiLCOUirr3UcCa5Hu++4C8bB2LNdMR0+VBnmmpzNijv3U6D4CWSMUy8d/MBYGwhrTRy8p1H8B",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "call_private_function_internal",
@@ -1627,16 +1627,54 @@
       "verification_key": "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"
     },
     {
-      "name": "is_reject_all",
+      "name": "set_reject_all",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "reject",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "206160798890201757": {
+            "error_kind": "string",
+            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "JwACBAEoAAABBIBIJwAABAMnAgIEAScCAwQAHxgAAwACgEcdAIBHgEcBLgiARwABJQAAAEwlAAAAaSgCAAEEgEgnAgIEADsNAAEAAigAgEMEAAMoAIBEAQAAKACARQQAACgAgEYEAAEmJQAAAi4eAgACAScCAwAALQgBBCcCBQQEABABBQEnAwQEAQAoBAIFLQwFBi0OAwYAKAYCBi0OAwYAKAYCBi0OAwYtDQQFACgFAgUtDgUEKwIABQAAAAAAAAAAAgAAAAAAAAAALQgBBicCBwQFABABBwEnAwYEAQAoBgIHLQwHCC0OAwgAKAgCCC0OAwgAKAgCCC0OAwgAKAgCCC0OBQgtDQQFACgFAgUtDgUELQ0GBQAoBQIFLQ4FBi0IAQUAAAECAS0OBAUtCAEEAAABAgEtDgYELQgBBgAAAQIBLgqARQAGLQgBBwAAAQIBLgqARAAHJwIIAAEnAgkECi0IAAotDAULLQwEDC0MBg0tDAcOLQwIDwAQAAkAJQAAAlctBAAAJwIIBAktCAAJLQwFCi0MBAstDAYMLQwHDS0MAg4AEAAIACUAAAJXLQQAAC0NBwILKAACgEQACCQCAAgAAAHRJwIJBAA8CQEJJwICBAgtCAAILQwFCS0MBAotDAYLLQwHDAAQAAIAJQAAA2stBAAALQ0EAgEoAAKARgAFLQ0FBAo4BAMCCygAAoBEAAMkAgADAAACIiUAAAR+HAwBAgAwDAACAAQmKACABAR4AA0AAACABIADJACAAwAAAlYqAQABBfeh86+lrdTKPAEBAiYlAAACLi0NAwYtDQQHCygAB4BEAAgkAgAIAAACfScCCQQAPAkBCQsoAAaAQwAHJAIABwAAAvcjAAACki0NAQYtDQIHLQ0DCC0NBAkuBAAGgAMoAIAEBAAEJQAABJAuCIAFAAoAKAoCCwA4CwgMLQ4FDAEoAAiARgAFDjgIBQYkAgAGAAAC4iUAAAUeLQ4KAS0OBwItDgUDLQ4JBCMAAANqJwIGBActCAAHLQwBCC0MAgktDAMKLQwECwAQAAYAJQAAA2stBAAALQ0BBi0NAgctDQQILgQABoADKACABAQABCUAAASQLgiABQAJACgJAgoBKAAKgEUACy0OBQstDgkBLQ4HAi4KgEYAAy0OCAQjAAADaiYlAAACLi4IgEUABSMAAAN7DSgABYBDAAYkAgAGAAAD6yMAAAOQLQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARgAGJAIABwAABAkjAAAEdS0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAABJAuCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAEdS0MBgUjAAADeyoBAAEFAtxuJ4B2Ep08AQECJi4BgAOABgsAgAYAAoAHJACABwAABKsjAAAEti4AgAOABSMAAAUdLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABQkuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABNgoAYAFBAABAwCABgACgAYjAAAFHSYqAQABBUWnynEZQeQVPAEBAiY=",
+      "debug_symbols": "7Z3dbts8DIbvJcc50A8pUb2VDx+GtE2HAEFapO2Aoei9z8liJ40oC6aCDYN5UtQtX4t+IokSFUsfi8f1/fv3b5vd0/Pr4u6/j8X2+WH1tnnedVcfn8vF/X6z3W6+f7v888IcflhrjoLXl9XucP36ttq/Le5sMmG5WO8eD7866G7xtNmuF3doPpeZMZCHkzEQuME4JMaYMLqTMSHFS+P/l507yLpDBIM7BsfdsSb43thaPxjb4Dlr7B/UmbPr3iFjGxPgyTimdL6zI2KsfTQ9FX8m6DiXnbP9jZ3zftwYIZ5sEejS9MDPGeXXxA+UXxO/pPxa+Hmtf238tP418QOtf238SPm18EOn/Jr4ReXXwi9Y5dfELyi/Fn5R529VfmR7fuQyfqD8mvjp+LmJH3nlV+EXBtvw1bTj54y23zZ+Ov9o4me1/bbx0/rXxM9p/Wvjp/WviZ/X/EsbP53/NvEDzb+08dP18yZ+qPmXNn6g/Jr4af6liV/Q8TMDRReFcihRR7oMFB2+5lBIxwQMFB1oMlA0eudQkoZkBormqTIo3mhIZqBoSM6hWE0TMVA0JDNQNCTnUPQtBwaK12E+A0VrCgNF+5QcykxXHrztXe7WTsM1lJkuJ1SgaE1hoMyzTxmHMtNsfgXKPLP541DiPCeEFSja0TJQtKPNoRAolByK1pQcykyz+RUo88zmj0KBmWbzK1Dmmc0fh2J1lsxA0ZDMQNGONofitKNloOgsOYcy07c7KlDmGZIj9LYuotz4QBDmGb+nELThDCMalxGcZ1y7IUHUVtxIcKZb39yS4DzzrZMIxtTvfmPJZrF4ptvf3JIgKMFGghqLGwnSPKcZtySoo5lGgkkjSStBHc20EUSjdbCVICjBRoI6mqkSTH54vgQZQauxuJHgLQ6l6Kx7YwdYIYiYeucDXRxfYk3kGIZ+Q8cYzxuy2uh+O4//sPPe/8PO32IvoL/nfL3XuPgOPe88mL4E261nfSkityYT+zZIhs63Zk/hgcENSOcbe/BH39H+cd99GHxHGvc9kk89eEpm3NhaIBy6XrxY/fl94FAojDDM0PtZQ+mqQwuFoDousvys2OJA9Qjnq6jQdVZEJBAVuoqKiF9ltTScHuVMBgJ598Bd1JispOAkoiAQFXKQFRFfjRAGehjttaiwsURFFAWi5CQimi6KxktEkpIK7QnTMBQJ9votpVhoTxURCkSF9lQRkUAEEhCF+DQuQgm9wpst/jxk9HjdnmIAiYgEosI+QBVREIgKzb0ikoAgCfIkKSkJkJNxEpEAORW+WejDMCr0ZDNREIgKG/dWRCQQFV7JrYiSQARRICoMHkfDJxVeCayIkkAUJCUl9pli6Id7XXd1JUl8dEpDHiDFkEnCZAkfzsYlMF0iGO6mQvyriKJAVIh/FZGkJJSUhJKSgqSkICkpSj6nKCmJJM9UWAkbFxUWfyoikIgETcMafpA81p90GhZ5cv3sNkGumd4JWcO32/FyvMA3PrtT0aBAk6YzQBBoBOXw7zcn6uvBl4xur6Hpmigoh2/iF8/DaEhQ34ima/ilyVGNNUagCdM1/NZUFY2gHCd4numxv9NM/3ysn1gPPrurH6v9ZnW/XZ+OLH963z1cnGD+9vNlfXWY+cv++WH9+L5fH441P59ofsDiukmBQzjWle6ye4hll706unb4L2L339iV2pX8Cw==",
+      "brillig_names": [
+        "set_reject_all"
+      ]
+    },
+    {
+      "name": "_set_authorized",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "view"
+        "internal"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "on_behalf_of",
+            "name": "approver",
             "type": {
               "kind": "struct",
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
@@ -1650,14 +1688,23 @@
               ]
             },
             "visibility": "private"
+          },
+          {
+            "name": "message_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "authorize",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "boolean"
-          },
-          "visibility": "public"
-        },
+        "return_type": null,
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -1667,13 +1714,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "9474245853673257536": {
-            "error_kind": "string",
-            "string": "Function is_reject_all can only be called statically"
-          },
-          "16761564377371454734": {
+          "6304245522015439386": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Function _set_authorized can only be called internally"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -1681,36 +1724,50 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bbuM4DIbfJde9EKnzvMpgUfSQKQIESZG2CyyKvvs6mdhOKyEei0KRjP6bok7IkPosi9TR74vH5f3b0+1q82v7svjx832x3j7cva62m+7q/eNmcb9brderp9vTjxdq/4cUHxRenu82++uX17vd6+IHsWW6WSw3j4f/je5+5Ndqvdxf+Y+bRN6Tikdx38kP0l5nhCM7PgpHDp+E/7npPPJ/4pH95NFej7hQr9Ae2zI9rXJ6JgR9VDNRmUHLmgxBUq4XJqKTm+NCTjq4XjiGQVYz/3bHXJY78aLcMZdFx1wWHXtZdGy4KHccX5Y7/qLc8fTd7tjeHVb8yZ1MPIvG9vEsxvGXD+EqkdbDLxtWo2zOZaZoei+Y+Lyw5f537T7qjqIHfg78JPyCAj8RPwt+En4R9U/GD/VPwo8V6p+MnwE/Eb8AfhJ+pMFPxM+Dn4QfM/iJ+KH/NsnPqZ6fo6/8NPIXGT/kzzJ+Efym+A2y7rPonp/D8yvjZ8BPxA/Pr4ifR/2T8UP9E/ELqH8yfhh/EfGL6P/K+GH8RcJPK8yfy/hh/EXEj9B/k/HD+IuMH/LnFApjUigDBZluCkUjfc1AQU6QQjFINDNQEL0zUBCSUyjfv0b+GqAgJKdQHEJyBgqGiVIo2DuRg4KQnELBLoccFKT5KRTsR8hBQZuSQDHYOZCBwm1CYT1COdnrfoSi20zzPfWHIbDXulh4T9C02SeYQ5DcWD4XKCHYZgeiIkHbZhCsSLDRta41CRoQnCLo/XDego9JLG50vWtFgr7NydWaBBGLhQRDmyN/NQkim5ESRCQREowGBIUEUQdlBK1CNiMliGxGSJCQzUgJIpuREkQkERJsdNFxTYKIJEKCjS5nrkmwzUURswhG6g8up8gJwe8/K/qvI1hhvphC6C2czkjnCVrre+lu0mFkSFrlGLr+ZHfvxwONu+fq4LzV1+z8NZN37oqd/4O1nKynnB+ebSKvPpnIuGNDv2bDOzXxrgavBz+8YT4v3LVYY4gho+Kp+KGs/tvL6seynrRkWfet79smG0bXtVEH3wNfse/Xy901uk9bq8ELTeZLoHSNDpxMQEFNSaGwAZQUSptjPuehaNSUDBTUlBSKaXPAjyMPUJSd6OiqoVfcFTUkBNsc8KtI0LaZAc0iSHosn6WEYJvpUkWCjS5KrUmwzfBakWCji1LnEXTj0EVIIkmji7FmETSqPwm9+zepg7HNbV71CHrV5vRlTYLIZoQEGz3QcRZBy0P5rFUJwTYXY1Uk2Oou6ooEEYuFBDUyailB9OqEBA2yGSFBjA+KCWKMWkiw0QP9ahJEHRQSbPSowHkEhwVIZCMnBJHNCAk2+qqmigQbfdlQTYKIJDKCodEXDtUkiPFBKUHEYiFBwvjgJEE9blLS+us8SWh0u2tNgojFQoIasVhKELFYShCxWEgQ66jFBJHNCAla1EEpQWQzQoIO2YyUILIZKUFkM9MEjR8Iuq8zTaHR9y9VJBgwyi8liFgsJBiRD0oJok8iIxixll9KEGv5hbshIhkQFBJEOygk2OjZLRUJYi3/F4IdFFKc7al53Z+34I1OdPIr0qPpDUWb2rGqQMcU6IT5Ovm1uecPneg+8iVa+TWYk1quRCsU2QpFtmKRrVhiixQVaZXcL6IiW1RUrvyOt0ktU6QVSrQ0F2n52W0MmSz3roXun2PO6Mxvlyj/FJ+34wt8y4+ITejE+TpBz2cQ5reZFOfb4fxzO6Ez/54yFdihAjv55zXavl5Hz6mOna+jC+zkX7d7Xic/Bz2hU2DHFtjJz6yd3J+MTj6un7+nzs/X8QV2girQsfN1YsGzEOe3B1rpAp04X4dMgU6BHS4oD8+vO1pTgc7MevDRXf17t1vd3a+XL53G/su3zcPrars5Xr7+99x/c79brderp9vn3fZh+fi2W96utw/77xbq+OdnV+FvOOpDBtdd7o/Lpt+X+8JwNN23rrPaWf4f",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "is_reject_all"
+        "_set_authorized"
       ]
     },
     {
-      "name": "set_authorized",
+      "name": "utility_is_consumable",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public"
+        "utility"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "message_hash",
+            "name": "on_behalf_of",
             "type": {
-              "kind": "field"
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ]
             },
             "visibility": "private"
           },
           {
-            "name": "authorize",
+            "name": "message_hash",
             "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
         ],
-        "return_type": null,
+        "return_type": {
+          "abi_type": {
+            "kind": "boolean"
+          },
+          "visibility": "public"
+        },
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -1720,28 +1777,23 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bbts4EIbfxde54PnQVykWQZKmhQEjKZJ0gUXRd18pjWQ3HInWjDZRlv9NUNf8xdHnEWdIUaOfuy+31z++Xe7vvt4/7j59/rk73N9cPe3v77pPP39d7K4f9ofD/tvl6X/vVP9H6/AsePx+ddd/fny6enjafdJe54vd7d2X/p82dof4uj/c7j559+uiaOySdS+NXXJmbBwt0Tj5aF4aJ5/iaeO/LnbaaNIcl/Vojk7z5mgV7NBYazs21iFRrVMYGufjga0xv80JmzLHqm2Z4zdljtsWHbctOn5bdLzbljlpU+YEuy1z4lub4wdzjDJ/mFO2jdn5l8Yx5+ORTfJEazse2Rl1bEuZbHQe4pox2sw39mY4rjfxtGnPLxrwE/EL4CfhlzT4ifjB/0T8MvxPxg/+J+FnlAI/ET8HfiJ+Gfwk/LQFPxG/BH4Sfgbztyq/oAZ+QRf8kL+I+FnkzzJ+Hvxq/Ma24c+mPT+P61fEL2D+IeOH61fEL8L/ZPzgfyJ+Cf4n4+fAT8QP818Rv4z1Fxk/3D+X8LMK6y8yfpi/ifhprL/I+CF/JqDgplAJxThAKaEgfS2hWOQEBBQkmiUUh+hNQEFILqF4rFMRUBCSCSgIySWUgGUiAgpCcgklIiQTULBKU0JJSPMJKPCUEgoeMiihuEZ3zhp7hOL8ayiNbqeL4zP9JlrLbvxMsM3Z4xKCOhzPL6TXWxKda/PCXJGgx1UsJdhmGrEiwUY3di4iGONYWiDmIhY3urVzTYJt3kdckWBELJYSbHORa0WCjZZoWJMgIomQYEY2IyUIH5QSRDYjI+gVshkpQWQzQoKNbphdkyAiiZQgIomQoEEkkRJsc5vQigQb3ea7iGDWQ0ltnU1B0GFWJyXo5AR1SkPj0zvSNEHv49DaZ3fC2yqidcjDmUYd/jjys/H5Axvv4wc2fo1bG+9m/BklI056+K8rUPvotmVO3pQ5aVt00rbo5G3RyWlL5oQznq1+U3Pipsw5YyFjZXP+V5UTwxnLGOA3w88o8BPxg/+J+Fn4n4wf/E/GL4OfhN8Z24zBb45fAj8JP2/AT8Qvgp+EX8D8TVI5OwTkLyJ+EfmzjJ8Dvxq/mcprISJ/EfFLyJ9l/OB/In4Z/ifjB/+T8IsK8zcZvwB+En64/ybkh/mbiB/uvwn5OfAT8cP9DxE/i/yZgIJF5RKKQ6ZLQEH6WkLxyAkIKEg0CSiI3iWUgJBMQME6VQklIiQTUBCSSygJy0QEFIRkAgpCcgnl7Z+Q2T6UpJDmE1DgKQQUjCklFNNmnjJbeTy5Ni+f9SqPp0Y3ZK9Xszj5Ni/MFQkGXMVSgm1GzBUJxjZX0darLJQa3Rq7IsHU5vrcmgQRi4UEc5uz9DUJOhAUEkQkkRHMCtmMlCB8UEhQI5uREkQ2IyTY6HbjNQk6EBQSRCQRErSIJFKCiCRCgg6RRFb1OeNOk5TgGsV/uAWQuyXzI0O6AHIMgx0xHit/dtfVb+PjBzZ+jbIt72b8Grc23s/4+qgRasY7NTZ2JyWN+i7K1knFYYxJKh0PHS3R2KVhd4LLxwNbp55tP6PYxdq22zDa7tO87THZsWB5t+w731hrl/w49HoTTpt356pVo0tOVo1WWO1ejdgdlTaDXoWKhq8QVEybm65rVNqculSoWPgKRQW+QlBpdOpqshmpKF9SafNpjhqVNjeSVaj4NvOVGpU2yx5UqDRaIbdGBaMtRQWjLUGl0Rq1NSrwFYJKo/VQ56l0q7VNvqJ0fh6kG339co0KfIWgcsZKQoNUnAYVggp8haDi4SsUFd8klUq+Etp8pXqNigMVgkqb+UqFyhmlvVqk0mZkrlBJGG0pKhhtKSoZVEoqGb5SUjGqzfWVCpVI3iWLx713zhYa+gHY7IaOsi/6sfSbZSqasFyjFUNDXy9q3Brd/e6pVGWOamKVr6ZKHJVl9WVZfTlWX47Vl2f15Vm/V2D1FVjnNZEl11SBo5rIsmoq1pVCR+nZMcbSb0LLatjQnA2hWT4uOfoqnu3HGcvQxOUaehddReOXM3CKoWH0Q1+3FQ3jNw2MfgKjH/p6zX7w6xxNqYnLNYnRD10opaLxizVeKYaG00+u/D6Eho7rs7+p13m5xjD6sYahics1bvm14L1iaJaPB57ei1TRLM8JfWT0ExnnExm+kxi/T1ruB8FxsoTgFUtFZwldajlOnrwuVMFwVBNv3K6pPEtFZ5DdCY+qVNCIU4Wl1fAe7P4hqlLlWKrEUU2VQqmoaI/yZmTYDSSFauIpkpqK1Zd1LFXmqCb2a1dUE4/M1lSRo5qYydRUiaOKrL7ixHnF8aljn4soP/Xeg4pqopBcTZUYqjSx8lRTcWikiTeo1lQchmmi+Io9PiVurS5VmaOaWMuoqSJHNbGPpKbyLBWLhmeR96y+Aot8YJGPLPIT0dy6OKpCMdqkiZfI1FSJo5p4r3tNlRmqPJE5VFQTOUBNFRiZw2TZq4qKkxFlu7ivX92nv68e9lfXh9vHTtN/+ePu5ml/f/fy8emf78M31w/7w2H/7fL7w/3N7ZcfD7eXh/ub/rudevnz2aZ44VTqrek/mo6o8ab/2DugU/nCad312vX8Lw==",
+      "bytecode": "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",
+      "debug_symbols": "7Z3dbts4EIXfxde5IDn83VcpFkGSpoUBIymSdIFFkXdfyWvKP+RK0YzQlcNzU8Q1j3T8SSbnUBL9a/P18f7n99vt07fn180fX35tds8Pd2/b56fu1a/3m839y3a3236/Pf3vjer/MWrf/vXH3VP/8vXt7uVt84dWVsebzePT1/3fIXTb+LbdPe5fvd8U7UP0h9axf//QNuhKU2fcoalz6rhZ69//vNkYvYSbSCG7cWncjaV0aGp9LNyYRdxEm92kOO7Gq8zGG1+4oSXcJGMOrRO5CTdRHZoGVR4pW3PjfNT56AZ1/LT9ka5Y95Sda03HPXiqtR5OMX2CkYzbu3GrcuNX5Sasyk1clZu0JjekVuVGr8qNWZUbWpWb394Xu+zGKHPmplIaJJsHtZDSccsmxkprCnnMsXQsJEzNsjE6b9gYovHGzuaSwNl42rTH54BPgs8DnwRfAD4Jvgh8EnwJ+AT4rAI+CT4NfBJ8Bvgk+Aj4JPgs8EnwIXWI8CF1TOI7sojmEh9ShwgfUocIH1LHFD4/tPXnTTt8DqlDhA+pQ4QPqUOED6lDhM8CnwQfUocIH1KHCB9ShwgfUocIH1KHBJ9H6hDhQ+oQ4UPqEOFD6iiZWDApmCAflExQ9JdMUMmXTFCel0xQcxdMAgrpkgmq45IJSt6SCerYkokFk4IJ6tiSCerYkgnq2JIJ6tiSCerYgklEHVsyaXQsdkcm3l8yabOPDTa3NcHxG/cA2+yQ5wDUflhlQQd1eb9hbLP3Xg5garOrXxBgm/MbCwJsczJkFsCQ8vMSOurLUTi1OXOyIEALgDKAbc7JLAiwzQmcBQEiiQgBIokIASKJyABqhSgiJYgsIiWIMCIliDQiJWhBUEgQeURKEIFEShCJREoQkURKEJlkkmCi4fMlWxDUyCRSggtkEh2HhdCNdRMEnUvZvEvupLUKldY+5WXiw8n3p9/y3ry5ZvN0zebtNZufrj+NW7TXGFtEWmu/LjthXXbiuuykVdkxal129LrsmHXZoXXZsb/bzqdaCFEbB34ifh78RPwC+In4RfAT8UvgJ+FHCvxE/DT4ifgZ8BPxI/AT8bPgJ+KH/CFZC1sT8oeMH/KHjB/yh2RlNU3IHyJ+FvlDxg/5Q8YP+UPGD/lDxs+Cn4gf8oeMH/KHjB/yh4wf8oeMH/KHiJ9D/pDxQ/6oQEGoqEBBUqhAsYBSQkFNX4GCQr0CBdV3BQpK6goU1MklFI/itwIFFW0FCiraChRUtBUoFlBKKKhoK1BQ0VagoKKtQEFFW0IJjdYpY4uN6w/8GspnhLLcauM6tDlULbdWsQ5tjmtLEmxzEFySYJsj5pIE25wwWnBlodjm7NKSBNss8ZYk2Oa81ZIE25zkWpKgBUEhQWQSKUFkEilBZBIpQWQSKUFkEiHBhEwiJYhMIiWITCIliEwiJWhBUEgQmUS46nNCJpESXCCTcBdA9tEczdcXQA4++wjhuHCMDuZf8/GazafrNW+Uumbz0/WntRPmfRiu/PiUznZR+cJ2F4ryF7ZLYEProKtfWJuGPkaH8cZhuL8j+JMP6mttbczbdVqdtd1DMW1C0cNy7BRKKAQoJRQLKCUUByglFA8oJZQAKCWUCCgllPR5oKgjlDQBhcxQ6hHp4wckW01kKgz5Rp14pmoZGXX2HE9SVr2tHw6OJ3/Wtj84H/jJJhyc/+3g/P4K3w0HpyuQxnl32SjbOGViD97NFXunK/be5tVZMnmK0hC5i+kho9u84DoBpc1rqONQTJuXRUnTAMX4AkqbVzonoLR58XICSpvXIyegWEApobR51XACSpsXAiegNFrRjkNptKIdh9JoRTsKpdHfZZqAMt3RfsZfKh/PPh/4BZEGoURAKaGkNqGM9ikf+AGPBqFoQCmhGEApoRCglFAsoJRQHKCUUBqtaMehNFrRjkNptKIdheJQvJVQ6mudBp+3H7wtJNW+OQ1kUij34udLwnxJnC+pphythscWzm4GOYiC4og0R2Q4IuKILEfkOCLPEQWOKHJEnDMics6IyDkjIueMiJwzInLOiPrSC6PdSX2tgWRyd5hsKZn/Ra8/yTu6l/qjq+MSmi+x8yXzO+A0vwNO8zvg+lNOKeajfzawHSRproTqT/SMS/TEZ6lIzNyPT/VnMMYldr7EzZf4+ZIwXxLnS9JsSf1u1nGJni+Zf/QNYwwgozmi+hig3XA74v4WxAsRcUSWI3IcUb0q0DGX0NqoEkR9rLYmV/Tdn8WeSHFEmiMyHFH9ODk70HP9LaMXIssROY7Ic0SBI4ocUWKI6rP62qUh63ldjA/1We8pkeGIiCOyHJHjiDxHFDii+sGl42Pj5IrvUz31T4k0R2Q4IuKILEfkOCLPEQWOKHJEnDPCc84I/x9nxPCki6ZYdCzecETEEVmOyHFEniMKHFFkDJ+eUxIETkkQZpcE792rv+5etnf3u8fXTtO/+fPp4W37/HR4+fb3j/zO/ct2t9t+v/3x8vzw+PXny+Pt7vmhf2+jDv98oWBvKLnOzL4oNo5ujIv9y94aJd+9G7u9dnv+Bw==",
       "brillig_names": [
-        "set_authorized"
+        "utility_is_consumable"
       ]
     },
     {
-      "name": "is_consumable",
+      "name": "consume",
       "is_unconstrained": true,
       "custom_attributes": [
-        "public",
-        "view"
+        "public"
       ],
       "abi": {
         "parameters": [
@@ -1762,7 +1814,7 @@
             "visibility": "private"
           },
           {
-            "name": "message_hash",
+            "name": "inner_hash",
             "type": {
               "kind": "field"
             },
@@ -1771,7 +1823,7 @@
         ],
         "return_type": {
           "abi_type": {
-            "kind": "boolean"
+            "kind": "field"
           },
           "visibility": "public"
         },
@@ -1780,17 +1832,17 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "5019202896831570965": {
+          "715723737710351018": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "rejecting all"
           },
-          "5444967152290923376": {
+          "5019202896831570965": {
             "error_kind": "string",
-            "string": "Function is_consumable can only be called statically"
+            "string": "attempt to add with overflow"
           },
-          "16761564377371454734": {
+          "12737498021964987455": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "unauthorized"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -1798,10 +1850,10 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "is_consumable"
+        "consume"
       ]
     },
     {
@@ -1821,13 +1873,13 @@
         }
       },
       "bytecode": "H4sIAAAAAAAA/7WTPQ+CMBCGi2KUjzjgoD+jBAyM+LG4OLpXCkpUSAB3frqQXENtwKjAJU17FJ5736OVUB0SzDLqEAyyglmBecTtj8vhQY67hakIdfvku9i2lQZ/Peq3FGBKw/Ax4w/UfzwFzr6o+bwXVndWDo1b66g+H0P5Z/9vSP+LD5418GpAXnmew/oS5Nt74t+Oz8c5SNnXTR1EgnIxdK5CSd0lcZ4SP99QmgZZJhJGDWTUQlU56pVE8YG26fmRdgrSLEpikSZ/Sav6yu6lXLyr8eA57hCOizHTMAb+BDV3X+b2+feXkKuCJ+bT+1Nn6BAztEhI1oRS2yeGwK+CP38vlizs4eEFAAA=",
-      "debug_symbols": "rZLLqoMwEIbfJWsXuV/6KuVQosYSCFGiHijiu3cssZVa2o2bYSZ8DF+Sf0K1K8frxcem7dHpPKHQVnbwbYRpmgtUJh+Cv162xwgvhbAH33c2LmM/2DSgE8Gc6AK5WD96pWBH44ODiUK/45WWmdaYP1klPqCCiowKgV9rBZn/CkT4ETaaqdVGmO82nJmMcql3NuIQG81XG6O/20i8vo2kcmcjj7AxlGbaMPHDRuOMKvz2UzOM/zZ5WwaXI9aMsdokbrh17i18XWorV4/JLTHcJBDqGe5AGayF1Xc=",
+      "debug_symbols": "rZLdCoMgGIbvxeMO/P/ZrYwxrCwEsbAajOjeZ2EsarSTTj789OHjUd8RlCYf6qf1VdOB230Eril0bxsfu3HKQB6sc7Z+brcBnAsiC9+12s9t1+vQgxuCFMkMGF8uayHijMo6s3RTduCF5ImW83liBfqBMswSyhj8jqV8emQA0StsJBGrDVPnNpSohFIuDzbsEhtJVxslz204XN+GY36w4VfYKIwTrQj7YyNhQgXc/dQU25cOVufOpIhVgy82ievfrdmFrw1NYcohmDmGmwTGeo93wCSOjaM/",
       "brillig_names": [
         "sync_notes"
       ]
     },
     {
-      "name": "public_dispatch",
+      "name": "set_authorized",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -1835,11 +1887,18 @@
       "abi": {
         "parameters": [
           {
-            "name": "selector",
+            "name": "message_hash",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
+          },
+          {
+            "name": "authorize",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
           }
         ],
         "return_type": null,
@@ -1848,60 +1907,28 @@
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
           },
-          "715723737710351018": {
-            "error_kind": "string",
-            "string": "rejecting all"
-          },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "5444967152290923376": {
-            "error_kind": "string",
-            "string": "Function is_consumable can only be called statically"
-          },
-          "6304245522015439386": {
-            "error_kind": "string",
-            "string": "Function _set_authorized can only be called internally"
-          },
-          "9474245853673257536": {
-            "error_kind": "string",
-            "string": "Function is_reject_all can only be called statically"
-          },
-          "12737498021964987455": {
-            "error_kind": "string",
-            "string": "unauthorized"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "public_dispatch"
+        "set_authorized"
       ]
     },
     {
-      "name": "utility_is_consumable",
+      "name": "is_reject_all",
       "is_unconstrained": true,
       "custom_attributes": [
-        "utility"
+        "public",
+        "view"
       ],
       "abi": {
         "parameters": [
@@ -1920,13 +1947,6 @@
               ]
             },
             "visibility": "private"
-          },
-          {
-            "name": "message_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
           }
         ],
         "return_type": {
@@ -1944,51 +1964,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "utility_is_consumable"
-      ]
-    },
-    {
-      "name": "set_reject_all",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "reject",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "206160798890201757": {
-            "error_kind": "string",
-            "string": "Storage slot 0 not allowed. Storage slots must start from 1."
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "16761564377371454734": {
+          "9474245853673257536": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Function is_reject_all can only be called statically"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -1996,23 +1974,23 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3bbuM4DIbfJde9kCjq1FcZLIoeMkWAICnSdoFFMe++Tia2M5Eaj0WhSKH/pkhq0qI/SyJFHfKxeFo+vD/frTY/t6+L2x8fi/X28f5ttd103z5+3Swedqv1evV8d/rvhdr/0cocFF5f7jf7769v97u3xa2Oyt0slpun/Ufi7hY/V+vl4tZ2HxNhDoaPwhyYBmFvMsLBejoKBxv8qfA/N505IWtOCDyYo+xlc7RyphfW2gzC2oWcdBgfNAyyhuhgjjbXZY6/KnOIrsuc66JjrouOuS46rK/LHHtV5lh1XebwV5tje3NI0R/mpLI+sj0K+xjHO1OwGWkz3JlJjbI5k0nH/vmINF0WttTf15I/FT3wi+An4ecM+In4BfCT8POofzJ+qH8ifgH1T8bPg5+EX9TgJ+LnwE/Aj5QCPxE/C34ifhi/TfJzqufn9Dk/jfhFxg/xs4jf1yeqvx+/Qdb9Kbrnx2i/Mn4Yf4j4WbRfGT/UPxE/h/on44f6J+LnkX+R8cP4V8QvIP8i48fgJ+KH/IuIX8T4TcYP+RcJP6MQP2egYFIohaIR6WagIHzNQEFMkEIhBpQUCrx3CsXAJWegIE+VQmG45AwUuOQUikWaKAMFLjkDBS45hYJdDjkoCPNTKNiPkIOCPiWFgp0DKRRWbUIhM0Jhew6F2gzzvY69Fd6YYuEDwTbHBHMIajc+nwvn6zTZtDmAqEmwTSdYkWCja11rEmwzizaLoPfDeQs+Jr640fWuNQm2OblakaCDL5YSZBAUEkQ0IyTo4UmkBBHNCAkG1EEpQUQzQoIR0YyUIIOgkCCiGRlB2+g64poE4UmEBDU8iZQg5kmkBNtcFDGLYNQ0wKCEIGFUJyRoKswXd9K98OmMdJ6gtb6X7iYdRobaqBxDp3uEfjzQuGtXv41339h4/s7kOX5j4/9iLedJq8obz6ovQfPJSWP7IlLpoHzfxwQVxltnf1qBBzM4jjc2rH7bHr/cduMG2224bLsPpu+ZfIjqsrDWHOzQ9Vpyp+L7Z/Vt+kcz/GgHGc3nHXajm9AnoKCmpFBim8HRRSiu0dzDBBTUlBSKRk3JQGkz8USRBijKTgy41DA66x41nBOkNhNPNQkyCE4R1GZ8PqsTgm2GSxUJNrrFuCJBbtO91iQIXzxN0I0ZhpB4kkYPtJxFkJUakkUqqYONHmlZk2Cb02g1CSKaERJsdHvpLIKWhuezViUE21wUVJFgo4db1iPoFXyxlCAiaiHBRpOmNQkimhESRH5QSrDRDfw1CWJUJyTIqINSgugHpwn6YXGkjecnDPlGN/DXJIgMq5CggycREvTwJFKC8CRSgsgPCgk2uv28IsGI/OAkQTNuljFGJwSRH5QRDAq+WEoQvlhKEL5YSBBZfjFBeBIhwUYPOq5JEHVQSBDzJGKCDIJCgohmhASxEv0vCLIfCDqVEEQdFBK0yPILCTZ60HFNgogHhQSxG0JMEKvfhASxll+4GyIErFkQEsRMk5gg6qCMYMRa/jOCeyghGyT78dAuNmcqWuW3lUTuy4nWpjq2QCfO19GmQCfftC6eOaEVUZGWK9H65EzGKa2isrioLC4qyxaVZYvKckXvyxWV5Yue65ONv1NasUTrk6BwSquopUSa38fkF1ZE1ffVkRIdXdAv6XwrvlwOFdiWnxiY0OECnTCfAZsCnYJy8u32so4reKeuoBxfUE6+vUbb1+voKdHJ+9sJnYJy8ptnJ3TCbB1SpkCnoJz8AoOT95PT8bPfKREV6BSUY+bHQ5TfADOhM78tkDUFOvP7A8r/jtqEzvyYkHxBOb7geUJB3QkF7yfOrAe/um//3u9W9w/r5Wunsb/4vnl8W203x69v/730Vx52q/V69Xz3sts+Lp/ed8u79fZxf22hjn9+dC/uphuXHPx091UHc9ONog5dyP5qcN3V0JXalfw/",
+      "bytecode": "JwACBAEoAAABBIBJJwAABAMnAgIEAScCAwQAHxgAAwACgEcuCIBHAAElAAAASyUAAABoLgQAAYBIKAIAAgSASCcCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAACSR4CAAIJJwIDAAEKOAIDBCQCAAQAAACJJQAAAnInAgIAAC0IAQQnAgUEBAAQAQUBJwMEBAEAKAQCBS0MBQYtDgIGACgGAgYtDgIGACgGAgYtDgIGLQ0EBQAoBQIFLQ4FBCsCAAUAAAAAAAAAAAIAAAAAAAAAAC0IAQYnAgcEBQAQAQcBJwMGBAEAKAYCBy0MBwgtDgIIACgIAggtDgIIACgIAggtDgIIACgIAggtDgUILQ0EBQAoBQIFLQ4FBC0NBgUAKAUCBS0OBQYtCAEFAAABAgEtDgQFLQgBBAAAAQIBLQ4GBC0IAQYAAAECAS4KgEUABi0IAQcAAAECAS4KgEQABycCCAQJLQgACS0MBQotDAQLLQwGDC0MBw0tDAMOABAACAAlAAAChC0EAAAnAgMECC0IAAgtDAUJLQwECi0MBgstDAcMLQwBDQAQAAMAJQAAAoQtBAAALQ0HAQsoAAGARAADJAIAAwAAAeInAggEADwJAQgnAgEECC0IAAgtDAUJLQwECi0MBgstDAcMABAAAQAlAAADmC0EAAAtDQQBASgAAYBGAAQtDQQDCjgDAgELKAABgEQAAiQCAAIAAAIzJQAABKsvDAADAAEcDAEDARwMAwIAHAwCAQEmKACABAR4AA0AAACABIADJACAAwAAAnEqAQABBfeh86+lrdTKPAEBAiYqAQABBYN7SGg+6XpAPAEBAiYlAAACSS0NAwYtDQQHCygAB4BEAAgkAgAIAAACqicCCQQAPAkBCQsoAAaAQwAHJAIABwAAAyQjAAACvy0NAQYtDQIHLQ0DCC0NBAkuBAAGgAMoAIAEBAAEJQAABL0uCIAFAAoAKAoCCwA4CwgMLQ4FDAEoAAiARgAFDjgIBQYkAgAGAAADDyUAAAVLLQ4KAS0OBwItDgUDLQ4JBCMAAAOXJwIGBActCAAHLQwBCC0MAgktDAMKLQwECwAQAAYAJQAAA5gtBAAALQ0BBi0NAgctDQQILgQABoADKACABAQABCUAAAS9LgiABQAJACgJAgoBKAAKgEUACy0OBQstDgkBLQ4HAi4KgEYAAy0OCAQjAAADlyYlAAACSS4IgEUABSMAAAOoDSgABYBDAAYkAgAGAAAEGCMAAAO9LQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARgAGJAIABwAABDYjAAAEoi0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAABL0uCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAEoi0MBgUjAAADqCoBAAEFAtxuJ4B2Ep08AQECJi4BgAOABgsAgAYAAoAHJACABwAABNgjAAAE4y4AgAOABSMAAAVKLgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAABTYuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAABQUoAYAFBAABAwCABgACgAYjAAAFSiYqAQABBUWnynEZQeQVPAEBAiY=",
+      "debug_symbols": "7Z3dbts8DIbvJcc5ECnqb7fy4cOQtukQIEiLtB0wFL33OVlsJxZj1VSwH5gnw7zxtajHskjRsfW+eFjfvX37utk9Pr0svvz3vtg+3a9eN0+75uj9Y7m422+22823r+f/vDCHP8Cko+DlebU7HL+8rvaviy+ADmG5WO8ejn8n25zkcbNdN0eGPpaZfWjOczIPjX1n7RNjnNDjyThhvDD+f7kAoM945C48OuqSTIfC9iwKdYHTUYz2JKN0YHxSOcMQBONbYwA4uzjectbOn4zRYGdrD5cpv5CJXHshU+rPjDEy1jaY1mfbu4ycy4jQnhjR2nFjR+Fk6yiemx74ESq/Kn5e+dXwc6D8qvjp+Kvi53X81fHT8VfFLxjlV8WPlF8Vv6T8avhFq/yq+EXlV8Mv6fqtyC+2JQQXMeOn+UsNPzSaP9fxc8qvwM93tv7S9MAP9f6t4md1/VHHT+/fKn6k46+On46/Kn5Ox18dP1J+Vfx0/VvFz2v9pY6fPj+v4he0/lLHT9dvVfyi1l/q+Gn+zEDRh0I5lEQKJYei6WsGxRrNCRgommjmUECjNwNFQ3IOBbVOxUDRkMxA0ZCcQ7FaJmKgaEjOoZCGZAaKVmlyKE7TfAaKjpQcir5kwEGZZ/Sx0LqMFv0QykwfJxSgzHNOGYcS57kgLEAhhZJDmeeCcBzKTH83X4CiE20GhWb6C/cCFB0pORTQkMxAmWc1vwBlng/Yx6HgPGu0BSi6Ss6hWA3JDBSdaBkoOtHmUIgUSg5FR0oOxc0zJAdqbTE4ufGR4Dzj9xSC4CO1/Qtm+IY0+XnGtRsSDHoX1xKcZwn1hgTjPOutkwiG1H7oBSJksThqJKkkmOa5bLwlQY3FtQTnucy4HUFnNJupJaiRpJIgaDZTS1DHYCVB1GymlqBmM0WCyXb9S5QRnOlrFbckeIN5EGJsW8DzLTJYgs6l1nkfsT81mMAx9O23C0Povz0KAY/O32LziD/m/C2+/PTnnI//sPOf+GYP2pLz3b0NTbnpognGHdfVpoI3hQ11gu38CIQ4btzMWMF3jpBJ5+bHvqbf3tfQ9xXNuPsutHsHudi7bskeff/Et9X/Xt//Xe6efxQJpos6YM5UvwKJ5x/VlURs9AFw1Hd8WMr1/AOZgoh/BlESRYGIrzQ3s113n6IZggh8UQGo333qfCpoRUEg4l/5L4mcRMQPI0cdPRdgKOJz4oLoyuZdBVEQiMhKRFEgcpKWrtxPLnUpoIfhi1Dhyv00LuL3DSmJokAUrUQkAcHX50siAb1o2MgGtk/VrcNMlAQisBJREIj4ekBJ5CQiCQgrQW4lLZEEOUmQOwlydwW577JxG4cTS/QgEUWB6EqgLoiSQBRJIOLf2ymJ/PTwmYyRiEggAklLlu1Ts7zpktDhb5ESH51SV39JYVieSPy4G5e46ZI0WRIE6W66Ev/GRVfyyYIoCERJ0lIStATGoEglagtEbUGUqFDUFor6xf8KvahyIlWSqMiKVHHqzAKG/xZGwnYBnYjRTJ6OmmJTnN5OFPgW/XRNMgINTWeQJs+WAIYEGp51bMfBRU39pOHT3YJG0A5/n5/1h9NMH2/AP+AY1/BbWhQ0brrGgUDjp2u8oB0v6I8XjOsguD5h4jj4aI6+r/ab1d12fdoC/vFtd3+2I/zrj+f1YHP45/3T/frhbb8+bBPf7xB/GBpIsESPx3u5OWwcWjbj+eja4X8bP9C7ptWm5Z8=",
       "brillig_names": [
-        "set_reject_all"
+        "is_reject_all"
       ]
     },
     {
-      "name": "_set_authorized",
+      "name": "is_consumable",
       "is_unconstrained": true,
       "custom_attributes": [
         "public",
-        "internal"
+        "view"
       ],
       "abi": {
         "parameters": [
           {
-            "name": "approver",
+            "name": "on_behalf_of",
             "type": {
               "kind": "struct",
               "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
@@ -2033,16 +2011,14 @@
               "kind": "field"
             },
             "visibility": "private"
-          },
-          {
-            "name": "authorize",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
           }
         ],
-        "return_type": null,
+        "return_type": {
+          "abi_type": {
+            "kind": "boolean"
+          },
+          "visibility": "public"
+        },
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -2052,13 +2028,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6304245522015439386": {
-            "error_kind": "string",
-            "string": "Function _set_authorized can only be called internally"
-          },
-          "16761564377371454734": {
+          "5444967152290923376": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Function is_consumable can only be called statically"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -2066,14 +2038,14 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "JwACBAEoAAABBIBKJwAABAMnAgMEAicCBAQAHxgABAADgEcuCIBHAAEuCIBIAAIlAAAAUSUAAABuLgQAAYBJKAIAAgSASScCAwQBOw0AAgADKACAQwQAAygAgEQBAAAoAIBFBAAAKACARgQAASYlAAAEth4CAAQJJwIFAAEKOAQFBiQCAAYAAACPJQAABN8nAgQAAi0IAQUnAgYEAwAQAQYBJwMFBAEAKAUCBi0MBgctDgQHACgHAgctDgEHJwIBAAAtCAEEJwIGBAQAEAEGAScDBAQBACgEAgYtDAYHLQ4BBwAoBwIHLQ4BBwAoBwIHLQ4BBy0NBAYAKAYCBi0OBgQrAgAGAAAAAAAAAAACAAAAAAAAAAAtCAEHJwIIBAUAEAEIAScDBwQBACgHAggtDAgJLQ4BCQAoCQIJLQ4BCQAoCQIJLQ4BCQAoCQIJLQ4GCS0NBAgAKAgCCC0OCAQtDQcIACgIAggtDggHLQgBCAAAAQIBLQ4ECC0IAQQAAAECAS0OBwQtCAEHAAABAgEuCoBFAActCAEJAAABAgEuCoBEAAknAgoEAi4IgEUAAyMAAAGzDDgDCgskAgALAAAEWiMAAAHFLQ0JBQsoAAWARAALJAIACwAAAeInAgwEADwJAQwnAgUECy0IAAstDAgMLQwEDS0MBw4tDAkPABAABQAlAAAE8S0EAAAtDQgFLQ0ECy0NBwwtDgUILQ4LBC0ODAcnAgQBAS0OBAkBKAALgEYABy0NBwUKOAUBBwsoAAeARAAIJAIACAAAAlAlAAAGBC0IAQcnAggEAwAQAQgBJwMHBAEAKAcCCC0MCAktDgUJACgJAgktDgIJLQgBAicCBQQEABABBQEnAwIEAQAoAgIFLQwFCC0OAQgAKAgCCC0OAQgAKAgCCC0OAQgtDQIFACgFAgUtDgUCLQgBBScCCAQFABABCAEnAwUEAQAoBQIILQwICS0OAQkAKAkCCS0OAQkAKAkCCS0OAQkAKAkCCS0OBgktDQIGACgGAgYtDgYCLQ0FBgAoBgIGLQ4GBS0IAQYAAAECAS0OAgYtCAECAAABAgEtDgUCLQgBBQAAAQIBLgqARQAFLQgBCAAAAQIBLgqARAAILgiARQADIwAAA1AMOAMKCSQCAAkAAAP+IwAAA2ItDQgDCygAA4BEAAckAgAHAAADfycCCQQAPAkBCScCAwQJLQgACS0MBgotDAILLQwFDC0MCA0AEAADACUAAATxLQQAAC0NBgMtDQIHLQ0FCS0OAwYtDgcCLQ4JBS0OBAgBKAAHgEYAAy0NAwIKOAIBAwsoAAOARAABJAIAAQAAA+glAAAGBC8MAAIAARwMAQMBHAwDAgAcDAIBASYkAgAJAAAECyMAAARJACgHAgsAOAsDDC0NDAknAgsEDC0IAAwtDAYNLQwCDi0MBQ8tDAgQLQwJEQAQAAsAJQAABhYtBAAAIwAABEkBKAADgEYACS0MCQMjAAADUCQCAAsAAARnIwAABKUAKAUCDAA4DAMNLQ0NCycCDAQNLQgADS0MCA4tDAQPLQwHEC0MCREtDAsSABAADAAlAAAGFi0EAAAjAAAEpQEoAAOARgALLQwLAyMAAAGzKACABAR4AA0AAACABIADJACAAwAABN4qAQABBfeh86+lrdTKPAEBAiYqAQABBUuQaMa9+INwPAEBAiYlAAAEti4IgEUABSMAAAUBDSgABYBDAAYkAgAGAAAFcSMAAAUWLQ0BBS0NAgYtDQMHLQ0ECCcCCQQELQgBCicCCwQFABABCwEnAwoEAQAoBgILJwIMBAQAKAoCDT8PAAsADS0NCgYAKAYCBi0OBgotDgUBLQ4KAi0OBwMtDggEJi0NAwYMOAUGBwEoAAWARgAGJAIABwAABY8jAAAF+y0NAQctDQIILQ0DCS0NBAoAKAgCDAA4DAUNLQ0NCwAoBwINADgNBQ4tDQ4MADgLDA0uBAAIgAMoAIAEBAAFJQAAByouCIAFAAsAKAsCDAA4DAUOLQ4NDi0OBwEtDgsCLQ4JAy0OCgQjAAAF+y0MBgUjAAAFASoBAAEFAtxuJ4B2Ep08AQECJiUAAAS2LQ0DBi0NBAcLKAAHgEQACCQCAAgAAAY8JwIJBAA8CQEJCygABoBDAAckAgAHAAAGtiMAAAZRLQ0BBi0NAgctDQMILQ0ECS4EAAaAAygAgAQEAAQlAAAHKi4IgAUACgAoCgILADgLCAwtDgUMASgACIBGAAUOOAgFBiQCAAYAAAahJQAAB7gtDgoBLQ4HAi0OBQMtDgkEIwAAByknAgYEBy0IAActDAEILQwCCS0MAwotDAQLABAABgAlAAAE8S0EAAAtDQEGLQ0CBy0NBAguBAAGgAMoAIAEBAAEJQAAByouCIAFAAkAKAkCCgEoAAqARQALLQ4FCy0OCQEtDgcCLgqARgADLQ4IBCMAAAcpJi4BgAOABgsAgAYAAoAHJACABwAAB0UjAAAHUC4AgAOABSMAAAe3LgAAAYAFAQAAAYAEAAEBAIADgASACS4AgAOACi4AgAWACwsAgAqACYAMJACADAAAB6MuAYAKgAguAoAIgAsBAIAKAAKACgEAgAsAAoALIwAAB3IoAYAFBAABAwCABgACgAYjAAAHtyYqAQABBUWnynEZQeQVPAEBAiY=",
+      "debug_symbols": "7Z3bbts4EIbfxde54Gl46KsUiyBJ08KAkRRJusCi6LuvnEayHY7NeEZolPK/Caqavzn6THKGB41+rr7cXv/4drm++3r/uPr0+edqc39z9bS+vxuufv66WF0/rDeb9bfL/f9eme0fa+lZ8Pj96m57/fh09fC0+mQdOXuxur378vzv4Icv+bre3A5XJvy6qMona8pL8TSUn0rHwhQuLrqXwsXlg8L/XKysM2+xiA4setaRTOeF9fks0wXP6cinUUa+5ElFhiFoTfRjHdbu/TjRc6VzHAvvfbEffqZnc/KizCG3LHPSosyJy6ITl0UnLYtOiosyJ5tlmUPLMqf8aXNoNMcZd2AO415LoNG9lrL7ZpczU9on81I4+LAry5nsnB2/2DnvTxemkEYWIe8X3fIrAfxU/DL4Kfg548FPxQ/tT8XPov3p+KH9qfg5B34qfhH8NPy8BT8VPwI/Db9gwE/FL4Bfi1+eWGRX8UP8ouJHiJ91/BL4NfjFqWw8LLrll9B/Vfwy5h86fui/Kn4F7U/HD+1Pw88btD8dP6y/qPhZzH91/LD+ouOH/XMVPxfAT8UP8zcVP4/1Fx0/xM81lIBNIQYKIt0aCiF8ZaAEQKmhINCsoUR4bwYKXHINJWGdioECl1xDyXDJDBQsEzFQ4JJrKAUumYGCVZoKSjABUGooaCk1FDxkwEDp9eQs7aDE+BpKp8fpUhjLukTyws8E+5w9nkPQxhzG+0vm9ZHEEPvsmDMSTOjFWoJ9hhEzEuz0YOdZBFMZn6yw2Va+uNOjnTMSLH3uI85JEL5YS7DPRa75CFKnKRrmJAhPoiRoEc1oCaINKgk6RDNagohmtAQRzSgJdnpgdk6C8CRKgp2er52TIDyJkmCnJ3fnJBhAsEWw+On+SqgIRszqtARnOAFpcx5rcPt5z1mCRGU0ngrtZ0lPTOlYdunl48E3b41P9iMbXz6w8XNsbbyb8e2UEcHSrKPGqQzUVOKSzInGLsucZdGxy6Jjl0XHmWWZE5ZlTlmUOe2FjLnN+asyJ8b2Mgb4neIXHPip+KH9qfgR2p+OH9qfil+04KfiR+Cn4ZcM+Kn4BfBT8Svgp+GXMX/TZM6OGfGLil9B/KzjF8Gvwe9U5rVkEL/o+CF+VvGzaH86fmh/Kn4O7U/HL4Cfil8GPw0/7L8p+WH+puKH/TclP8zfVPwI+x86foifGShYVK6hxAAoNRSErzWUhJiAgYJAs4aS4b0ZKHDJNZSCdSoGClwyAwUuuYKSDZaJGChwyTUUC5fMQMEqTQ3FIcxnoKCl1FA8xpQaSug0TjmVeTzHPrvPfJnHc6cHsufLWZxTnx1zRoIZvVhJsPTpMeck2Ocq2nyZhUqnR2PnJBhAUEkQvlhJ0PY5S5+TIKIZJcFODxnPSRDRjJKgRxvUEgwgqCSIaEZJsNPjxnMSRDSjJEjwJFqC8CRagvAkSoIRnkSX9blgp0lNcIZxUJoAOWa3M55PgJziaEdKu8QxNrnfxpcPbPwcaVvezfg5tjbey3hr3rCtsNcHj1g/dW477P0c1MHYQ9NGUYpmd6+xcIV9HntsCs6dLjwMWWlKjmuDKfvFf99s/OM3m3Y368xp+ym50Yy8s90H/9v4NxwFXLDxH5m873O5z7sxYnPe0ytvaU3oM+BoUUFb4aj0+Qint36i4mJFpdOJd4tKn5PpBpVOJ8gtKn0unzaodLoU0KKC0ZajgtGWodJpHt4WFbQVhkrp87nF01Ss6/OFwKfnQdb3+XLLFhW0FYZKpy+EbowrIYJKTaXTFze3qARQYahkUKmpdPra6RYVjLYMlYTRlqNCoFJTyWgrHJUCKhUVx+ffS3GsIMXX+QWsN6zfKhObkmKtiedr+DdjNDRBoGGjk+1u8/hjm70t+lHlvEiVJCp+Dt9UieoKorqCqC4S1UWiuqLo94qiupLovlKUqPjRvqkKIpWopxR//hjDr3AWN46SJVSaIBiXAt+LT9fjBLbxCZAaGhJoyvkMQhBoBPUQzzqP7eDA8Y2afL4mCurh+/ne/TCaJGhv/N7XaQ2fDva0phiB5nwfTcYKNIJ6BLEACWIBsuf/PuTObwck8kYk8kaU2N9ou1Y1BbPJ1aoiUfHHqlsq/h2QTRXvL22eTuQ6U9GIlrcwuHEeYPdP/Y4qZ0UqEqmKRMW/B2hAODEcGkKtKhIVvyLeUvFv6miqkkTFr601VaK6jvQvKtNkMVpfq4pEdSRua6iO9K+WKglUyViRikQqCcN0ZL7nd0/qDBOTSnVkvtdSJYmKjxabKhKpikQVRDSCiDyJ6iIR+SgiH0Xk4xHycXowx+dqtEmJJKrsRKokURUvUmWBKvOxZEvFR5MND5v5eLKpyhKVO7uuX8PVv1cP66vrze3joNl++OPu5ml9f/dy+fTf9/GT64f1ZrP+dvn94f7m9suPh9vLzf3N9rOVefnz2cdy4YvZWrO9dMMCpaPny20X8cUOn/qh1qHm/wE=",
       "brillig_names": [
-        "_set_authorized"
+        "is_consumable"
       ]
     },
     {
-      "name": "consume",
+      "name": "public_dispatch",
       "is_unconstrained": true,
       "custom_attributes": [
         "public"
@@ -2081,35 +2053,14 @@
       "abi": {
         "parameters": [
           {
-            "name": "on_behalf_of",
-            "type": {
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress",
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ]
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "inner_hash",
+            "name": "selector",
             "type": {
               "kind": "field"
             },
             "visibility": "private"
           }
         ],
-        "return_type": {
-          "abi_type": {
-            "kind": "field"
-          },
-          "visibility": "public"
-        },
+        "return_type": null,
         "error_types": {
           "206160798890201757": {
             "error_kind": "string",
@@ -2119,17 +2070,38 @@
             "error_kind": "string",
             "string": "rejecting all"
           },
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "5444967152290923376": {
+            "error_kind": "string",
+            "string": "Function is_consumable can only be called statically"
+          },
+          "6304245522015439386": {
+            "error_kind": "string",
+            "string": "Function _set_authorized can only be called internally"
+          },
+          "9474245853673257536": {
+            "error_kind": "string",
+            "string": "Function is_reject_all can only be called statically"
+          },
           "12737498021964987455": {
             "error_kind": "string",
             "string": "unauthorized"
           },
-          "16761564377371454734": {
+          "14225679739041873922": {
             "error_kind": "string",
-            "string": "Array index out of bounds"
+            "string": "Index out of bounds"
           },
           "17843811134343075018": {
             "error_kind": "string",
@@ -2137,10 +2109,10 @@
           }
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "consume"
+        "public_dispatch"
       ]
     }
   ],
@@ -2210,28 +2182,7 @@
               "type": {
                 "fields": [
                   {
-                    "name": "reject",
-                    "type": {
-                      "kind": "boolean"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "AuthRegistry::set_reject_all_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "AuthRegistry::set_reject_all_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "approver",
+                    "name": "on_behalf_of",
                     "type": {
                       "fields": [
                         {
@@ -2246,25 +2197,25 @@
                     }
                   },
                   {
-                    "name": "message_hash",
+                    "name": "inner_hash",
                     "type": {
                       "kind": "field"
                     }
-                  },
-                  {
-                    "name": "authorize",
-                    "type": {
-                      "kind": "boolean"
-                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::_set_authorized_parameters"
+                "path": "AuthRegistry::consume_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::_set_authorized_abi"
+          "path": "AuthRegistry::consume_abi"
         },
         {
           "fields": [
@@ -2288,25 +2239,25 @@
                     }
                   },
                   {
-                    "name": "inner_hash",
+                    "name": "message_hash",
                     "type": {
                       "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::consume_parameters"
+                "path": "AuthRegistry::is_consumable_parameters"
               }
             },
             {
               "name": "return_type",
               "type": {
-                "kind": "field"
+                "kind": "boolean"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::consume_abi"
+          "path": "AuthRegistry::is_consumable_abi"
         },
         {
           "fields": [
@@ -2315,34 +2266,25 @@
               "type": {
                 "fields": [
                   {
-                    "name": "on_behalf_of",
+                    "name": "message_hash",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "kind": "field"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "authorize",
+                    "type": {
+                      "kind": "boolean"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::is_reject_all_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "boolean"
+                "path": "AuthRegistry::set_authorized_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::is_reject_all_abi"
+          "path": "AuthRegistry::set_authorized_abi"
         },
         {
           "fields": [
@@ -2350,6 +2292,21 @@
               "name": "parameters",
               "type": {
                 "fields": [
+                  {
+                    "name": "approver",
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "inner",
+                          "type": {
+                            "kind": "field"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                    }
+                  },
                   {
                     "name": "message_hash",
                     "type": {
@@ -2364,12 +2321,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::set_authorized_parameters"
+                "path": "AuthRegistry::_set_authorized_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::set_authorized_abi"
+          "path": "AuthRegistry::_set_authorized_abi"
         },
         {
           "fields": [
@@ -2391,16 +2348,10 @@
                       "kind": "struct",
                       "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
                     }
-                  },
-                  {
-                    "name": "message_hash",
-                    "type": {
-                      "kind": "field"
-                    }
                   }
                 ],
                 "kind": "struct",
-                "path": "AuthRegistry::is_consumable_parameters"
+                "path": "AuthRegistry::is_reject_all_parameters"
               }
             },
             {
@@ -2411,7 +2362,28 @@
             }
           ],
           "kind": "struct",
-          "path": "AuthRegistry::is_consumable_abi"
+          "path": "AuthRegistry::is_reject_all_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "reject",
+                    "type": {
+                      "kind": "boolean"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "AuthRegistry::set_reject_all_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "AuthRegistry::set_reject_all_abi"
         },
         {
           "fields": [
@@ -2459,121 +2431,121 @@
     }
   },
   "file_map": {
-    "120": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
-      "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = m.functions();\n    let functions =\n        functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n    let unit = get_type::<()>();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n\n        let mut parameters_size = 0;\n        for param in parameters {\n            parameters_size += size_in_fields(param.1);\n        }\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        let args = args.join(quote { , });\n        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public\n            // functions having this attribute. However, the public MACRO will\n            // handle the public_dispatch function specially and do nothing.\n            #[public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n    let size = array_size_in_fields(typ);\n    let size = size.or_else(|| bool_size_in_fields(typ));\n    let size = size.or_else(|| constant_size_in_fields(typ));\n    let size = size.or_else(|| field_size_in_fields(typ));\n    let size = size.or_else(|| int_size_in_fields(typ));\n    let size = size.or_else(|| str_size_in_fields(typ));\n    let size = size.or_else(|| struct_size_in_fields(typ));\n    let size = size.or_else(|| tuple_size_in_fields(typ));\n    if size.is_some() {\n        size.unwrap()\n    } else {\n        panic(f\"Can't determine size in fields of {typ}\")\n    }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_array().and_then(|typ: (Type, Type)| {\n        let (typ, element_size) = typ;\n        element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n    })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_bool() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_field() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.as_integer().is_some() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n        let struct_type = typ.0;\n        let generics = typ.1;\n        let mut size = 0;\n        for field in struct_type.fields(generics) {\n            size += size_in_fields(field.1);\n        }\n        size\n    })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_tuple().map(|types: [Type]| {\n        let mut size = 0;\n        for typ in types {\n            size += size_in_fields(typ);\n        }\n        size\n    })\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
-    },
-    "127": {
+    "104": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_contract_library_method,\n        is_fn_initializer, is_fn_internal, is_fn_private, is_fn_public, is_fn_test, is_fn_utility,\n        is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_utility(f: FunctionDefinition) {\n    // Check if function is marked as unconstrained\n    if !f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[utility] but not marked as unconstrained, add unconstrained keyword\",\n        );\n    }\n\n    // Create utility context\n    let context_creation =\n        quote { let mut context = dep::aztec::context::utility_context::UtilityContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    // Initialize Storage if module has storage\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All utility functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Inject context creation, storage initialization, and message discovery call at the beginning of the function\n    // body.\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_body(modified_body);\n\n    f.set_return_public(true);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::messages::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::messages::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n\n/// Checks if each function in the module is marked with either #[private], #[public], #[utility],\n/// #[contract_library_method], or #[test]. Non-macroified functions are not allowed in contracts.\npub(crate) comptime fn check_each_fn_macroified(m: Module) {\n    for f in m.functions() {\n        let name = f.name();\n        if !is_fn_private(f)\n            & !is_fn_public(f)\n            & !is_fn_utility(f)\n            & !is_fn_contract_library_method(f)\n            & !is_fn_test(f) {\n            panic(\n                f\"Function {name} must be marked as either #[private], #[public], #[utility], #[contract_library_method], or #[test]\",\n            );\n        }\n    }\n}\n"
     },
-    "130": {
+    "107": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/storage.nr",
-      "source": "use std::{collections::umap::UHashMap, hash::{BuildHasherDefault, poseidon2::Poseidon2Hasher}};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n    UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n    // This macro performs three things:\n    //  - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n    //    functions will have the storage variable injected and initialized via the `init` function.\n    //  - it implements said `init` function by allocating appropriate storage slots to each state variable.\n    //  - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n    //    macro.\n    let mut slot: u32 = 1;\n    let mut storage_vars_constructors = &[];\n    let mut storage_layout_fields = &[];\n    let mut storage_layout_constructors = &[];\n\n    // TODO(#8658): uncomment the code below to inject the Context type parameter.\n    //let mut new_storage_fields = &[];\n    //let context_generic = s.add_generic(\"Context\");\n    for field in s.fields_as_written() {\n        // FIXME: This doesn't handle field types with generics\n        let (name, typ) = field;\n        let (storage_field_constructor, storage_size) =\n            generate_storage_field_constructor(typ, quote { $slot }, false);\n        storage_vars_constructors =\n            storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n        // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n        // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n        // a contract.\n        storage_layout_fields =\n            storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n        storage_layout_constructors = storage_layout_constructors.push_back(\n            quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n        );\n        //let with_context_generic = add_context_generic(typ, context_generic);\n        //println(with_context_generic);\n        //new_storage_fields = new_storage_fields.push_back((name,  with_context_generic ));\n        slot += storage_size;\n    }\n\n    //s.set_fields(new_storage_fields);\n    let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n    let storage_impl = quote {\n        impl<Context> Storage<Context> {\n            fn init(context: Context) -> Self {\n                Self {\n                    $storage_vars_constructors\n                }\n            }\n        }\n    };\n\n    let storage_layout_fields = storage_layout_fields.join(quote {,});\n    let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n    let module = s.module();\n    let module_name = module.name();\n    let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n    let (module_name_str, module_name_len) = module_name.as_str_quote();\n    STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n    quote {\n        $storage_impl\n\n        pub struct StorageLayoutFields {\n            $storage_layout_fields\n        }\n\n        pub struct StorageLayout<let N: u32> {\n            pub contract_name: str<N>,\n            pub fields: StorageLayoutFields\n        }\n\n        #[abi(storage)]\n        pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n            contract_name: $module_name_str,\n            fields: StorageLayoutFields { $storage_layout_constructors }\n        };\n    }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n    // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n    // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n    // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n    typ: Type,\n    slot: Quoted,\n    parent_is_map: bool,\n) -> (Quoted, u32) {\n    assert(\n        typ.as_data_type().is_some(),\n        \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n    );\n    let (container_struct, generics) = typ.as_data_type().unwrap();\n    let struct_name = container_struct.name();\n\n    if is_storage_map(typ) {\n        // Map state variables recursively initialize their contents - this includes nested maps.\n        let (value_constructor, _) =\n            generate_storage_field_constructor(generics[1], quote { slot }, true);\n        (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n    } else {\n        let storage_size = if parent_is_map {\n            // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n            // in slots very far away from one another.\n            1\n        } else {\n            let (_, container_struct_generics) = typ.as_data_type().unwrap();\n            let stored_struct = container_struct_generics[0];\n\n            if is_note(stored_struct) {\n                // Private notes always occupy a single slot, since the slot is only used as a state variable\n                // identifier.\n                1\n            } else {\n                get_storage_size(typ)\n            }\n        };\n\n        // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n        (quote { $struct_name::new(context, $slot)}, storage_size)\n    }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n    if typ.as_data_type().is_some() {\n        let (def, generics) = typ.as_data_type().unwrap();\n        let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n            let maybe_key = generics[0];\n            let maybe_value = generics[1];\n            let maybe_context = generics[2];\n            quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n        } else {\n            quote {()}.as_type()\n        };\n        typ == maybe_map\n    } else {\n        false\n    }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n    let (def, mut generics) = typ.as_data_type().expect(\n        f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n    );\n    let name = def.name();\n\n    if is_storage_map(typ) {\n        generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n        generics[generics.len() - 1] = context_generic;\n    } else {\n        generics[generics.len() - 1] = context_generic;\n    }\n\n    let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n    quote { $name<$generics> }.as_type()\n}\n"
+      "source": "use poseidon::poseidon2::Poseidon2Hasher;\nuse std::{collections::umap::UHashMap, hash::BuildHasherDefault};\n\nuse super::utils::AsStrQuote;\nuse super::utils::get_storage_size;\nuse super::utils::is_note;\n\n/// Stores a map from a module to the name of the struct that describes its storage layout.\n/// This is then used when generating a `storage_layout()` getter on the contract struct.\npub comptime mut global STORAGE_LAYOUT_NAME: UHashMap<Module, Quoted, BuildHasherDefault<Poseidon2Hasher>> =\n    UHashMap::default();\n\n/// Marks a struct as the one describing the storage layout of a contract. Only a single struct in the entire contract\n/// should have this macro (or `storage_no_init`) applied to it.\n/// The contract's storage is accessed via the `storage` variable, which will will automatically be made available in\n/// all functions as an instance of the struct this macro was applied to.\npub comptime fn storage(s: TypeDefinition) -> Quoted {\n    // This macro performs three things:\n    //  - it marks the contract as having storage, so that `macros::utils::module_has_storage` will return true and\n    //    functions will have the storage variable injected and initialized via the `init` function.\n    //  - it implements said `init` function by allocating appropriate storage slots to each state variable.\n    //  - it exposes the storage layout by creating a `StorageLayout` struct that is exposed via the `abi(storage)`\n    //    macro.\n    let mut slot: u32 = 1;\n    let mut storage_vars_constructors = &[];\n    let mut storage_layout_fields = &[];\n    let mut storage_layout_constructors = &[];\n\n    // TODO(#8658): uncomment the code below to inject the Context type parameter.\n    //let mut new_storage_fields = &[];\n    //let context_generic = s.add_generic(\"Context\");\n    for field in s.fields_as_written() {\n        // FIXME: This doesn't handle field types with generics\n        let (name, typ) = field;\n        let (storage_field_constructor, storage_size) =\n            generate_storage_field_constructor(typ, quote { $slot }, false);\n        storage_vars_constructors =\n            storage_vars_constructors.push_back(quote { $name: $storage_field_constructor });\n        // We have `Storable` in a separate `.nr` file instead of defining it in the last quote of this function\n        // because that way a dev gets a more reasonable error if he defines a struct with the same name in\n        // a contract.\n        storage_layout_fields =\n            storage_layout_fields.push_back(quote { pub $name: dep::aztec::prelude::Storable });\n        storage_layout_constructors = storage_layout_constructors.push_back(\n            quote { $name: dep::aztec::prelude::Storable { slot: $slot } },\n        );\n        //let with_context_generic = add_context_generic(typ, context_generic);\n        //println(with_context_generic);\n        //new_storage_fields = new_storage_fields.push_back((name,  with_context_generic ));\n        slot += storage_size;\n    }\n\n    //s.set_fields(new_storage_fields);\n    let storage_vars_constructors = storage_vars_constructors.join(quote {,});\n    let storage_impl = quote {\n        impl<Context> Storage<Context> {\n            fn init(context: Context) -> Self {\n                Self {\n                    $storage_vars_constructors\n                }\n            }\n        }\n    };\n\n    let storage_layout_fields = storage_layout_fields.join(quote {,});\n    let storage_layout_constructors = storage_layout_constructors.join(quote {,});\n\n    let module = s.module();\n    let module_name = module.name();\n    let storage_layout_name = f\"STORAGE_LAYOUT_{module_name}\".quoted_contents();\n    let (module_name_str, module_name_len) = module_name.as_str_quote();\n    STORAGE_LAYOUT_NAME.insert(module, storage_layout_name);\n\n    quote {\n        $storage_impl\n\n        pub struct StorageLayoutFields {\n            $storage_layout_fields\n        }\n\n        pub struct StorageLayout<let N: u32> {\n            pub contract_name: str<N>,\n            pub fields: StorageLayoutFields\n        }\n\n        #[abi(storage)]\n        pub global $storage_layout_name: StorageLayout<$module_name_len> = StorageLayout {\n            contract_name: $module_name_str,\n            fields: StorageLayoutFields { $storage_layout_constructors }\n        };\n    }\n}\n\n/// Same as `storage`, except the user is in charge of providing an implementation of the `init` constructor function\n/// with signature `fn init<Context>(context: Context) -> Self`, which allows for manual control of storage slot\n/// allocation. Similarly, no `StorageLayout` struct will be created.\n/// Only a single struct in the entire contract should have this macro (or `storage`) applied to it.\npub comptime fn storage_no_init(_s: TypeDefinition) {\n    // All `storage` does is provide the `init` implementation, so we don't need to do anything here. Applying this\n    // macro however will cause for `macros::utils::module_has_storage` to return true, resulting in the injection of\n    // the `storage` variable.\n}\n\n/// Returns the expression required to initialize a state variable with a given slot, along with its serialization size,\n/// i.e. how many contiguous storage slots the variable requires.\ncomptime fn generate_storage_field_constructor(\n    typ: Type,\n    slot: Quoted,\n    parent_is_map: bool,\n) -> (Quoted, u32) {\n    assert(\n        typ.as_data_type().is_some(),\n        \"Storage containers must be generic structs of the form `Container<_, Context>`, or Map<Key, _, Context>\",\n    );\n    let (container_struct, generics) = typ.as_data_type().unwrap();\n    let struct_name = container_struct.name();\n\n    if is_storage_map(typ) {\n        // Map state variables recursively initialize their contents - this includes nested maps.\n        let (value_constructor, _) =\n            generate_storage_field_constructor(generics[1], quote { slot }, true);\n        (quote { $struct_name::new(context, $slot, | context, slot | { $value_constructor }) }, 1)\n    } else {\n        let storage_size = if parent_is_map {\n            // Variables inside a map do not require contiguous slots since the map slot derivation is assumed to result\n            // in slots very far away from one another.\n            1\n        } else {\n            let (_, container_struct_generics) = typ.as_data_type().unwrap();\n            let stored_struct = container_struct_generics[0];\n\n            if is_note(stored_struct) {\n                // Private notes always occupy a single slot, since the slot is only used as a state variable\n                // identifier.\n                1\n            } else {\n                get_storage_size(typ)\n            }\n        };\n\n        // We assume below that all state variables implement `fn new<Context>(context: Context, slot: Field) -> Self`.\n        (quote { $struct_name::new(context, $slot)}, storage_size)\n    }\n}\n\n/// Returns true if `typ` is `state_vars::map::Map`.\ncomptime fn is_storage_map(typ: Type) -> bool {\n    if typ.as_data_type().is_some() {\n        let (def, generics) = typ.as_data_type().unwrap();\n        let maybe_map = if (def.name() == quote { Map }) & (generics.len() == 3) {\n            let maybe_key = generics[0];\n            let maybe_value = generics[1];\n            let maybe_context = generics[2];\n            quote { crate::state_vars::map::Map<$maybe_key, $maybe_value, $maybe_context> }.as_type()\n        } else {\n            quote {()}.as_type()\n        };\n        typ == maybe_map\n    } else {\n        false\n    }\n}\n\ncomptime fn add_context_generic(typ: Type, context_generic: Type) -> Type {\n    let (def, mut generics) = typ.as_data_type().expect(\n        f\"Storage containers must be generic structs of the form `Container<..., Context>`\",\n    );\n    let name = def.name();\n\n    if is_storage_map(typ) {\n        generics[generics.len() - 2] = add_context_generic(generics[1], context_generic);\n        generics[generics.len() - 1] = context_generic;\n    } else {\n        generics[generics.len() - 1] = context_generic;\n    }\n\n    let generics = generics.map(|typ: Type| quote {$typ}).join(quote {,});\n    quote { $name<$generics> }.as_type()\n}\n"
     },
-    "148": {
+    "143": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "150": {
+    "145": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_enqueued_public_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_enqueued_public_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_enqueued_public_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_set_public_teardown_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_public_teardown_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_set_public_teardown_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "151": {
+    "146": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "152": {
+    "147": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field], hash: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values, hash) };\n}\n\nunconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field], hash: Field) {\n    store_in_execution_cache_oracle(values, hash);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field], _hash: Field) {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "163": {
+    "158": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{\n    note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n    utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::IndexedTaggingSecret,\n    traits::{FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(_nullifier: Field, _note_hash: Field, _counter: u32) {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n) -> [Field; ORACLE_RETURN_FIELD_LENGTH] {\n    // This wrapper exists to extract the ORACLE_RETURN_FIELD_LENGTH generic numeric param into a value and pass it to\n    // the oracle, so that it knows how big the return array must be.\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        ORACLE_RETURN_FIELD_LENGTH,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let MAX_NOTES: u32, let ORACLE_RETURN_FIELD_LENGTH: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    _placeholder_fields: [Field; ORACLE_RETURN_FIELD_LENGTH], // TODO: Compute this value automatically from MAX_NOTES\n) -> [Option<RetrievedNote<Note>>; MAX_NOTES]\nwhere\n    Note: NoteType + Packable<N>,\n{\n    let fields: [_; ORACLE_RETURN_FIELD_LENGTH] = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n\n    let mut opt_notes = [Option::none(); MAX_NOTES];\n    for i in 0..opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let maybe_nonce = fields[read_offset];\n            let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n            let packed_note = array::subarray(fields, read_offset + 2);\n\n            let note = Note::unpack(packed_note);\n            let retrieved_note = RetrievedNote {\n                note,\n                contract_address,\n                metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n            };\n\n            opt_notes[i] = Option::some(retrieved_note);\n        };\n    }\n    opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier)\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n\n/// Returns the derived app tagging secret ready to be included in a log for a given sender and recipient pair,\n/// siloed for the current contract address.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender_oracle(sender, recipient).compute_tag(recipient)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> IndexedTaggingSecret {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n"
     },
-    "166": {
+    "161": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/storage.nr",
       "source": "use dep::protocol_types::{address::AztecAddress, traits::{Packable, ToField}};\n\n#[oracle(storageRead)]\nunconstrained fn storage_read_oracle<let N: u32>(\n    address: Field,\n    storage_slot: Field,\n    block_number: Field,\n    length: Field,\n) -> [Field; N] {}\n\npub unconstrained fn raw_storage_read<let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> [Field; N] {\n    storage_read_oracle(\n        address.to_field(),\n        storage_slot,\n        block_number as Field,\n        N as Field,\n    )\n}\n\npub unconstrained fn storage_read<T, let N: u32>(\n    address: AztecAddress,\n    storage_slot: Field,\n    block_number: u32,\n) -> T\nwhere\n    T: Packable<N>,\n{\n    T::unpack(raw_storage_read(address, storage_slot, block_number))\n}\n\nmod tests {\n    use crate::oracle::storage::{raw_storage_read, storage_read};\n    use dep::protocol_types::{address::AztecAddress, traits::{FromField, Packable}};\n\n    use crate::test::mocks::mock_struct::MockStruct;\n    use std::test::OracleMock;\n\n    global address: AztecAddress = AztecAddress::from_field(29);\n    global slot: Field = 7;\n    global block_number: u32 = 17;\n\n    #[test]\n    unconstrained fn test_raw_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: [Field; 2] = raw_storage_read(address, slot, block_number);\n        assert_eq(read[0], 13);\n        assert_eq(read[1], 42);\n    }\n\n    #[test]\n    unconstrained fn test_storage_read() {\n        let written = MockStruct { a: 13, b: 42 };\n\n        let _ = OracleMock::mock(\"storageRead\").returns(written.pack());\n\n        let read: MockStruct = storage_read(address, slot, block_number);\n        assert_eq(read.a, 13);\n        assert_eq(read.b, 42);\n    }\n}\n"
     },
-    "168": {
+    "163": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/map.nr",
       "source": "use crate::state_vars::storage::Storage;\nuse dep::protocol_types::{storage::map::derive_storage_slot_in_map, traits::{Packable, ToField}};\n\n// docs:start:map\npub struct Map<K, V, Context> {\n    context: Context,\n    storage_slot: Field,\n    state_var_constructor: fn(Context, Field) -> V,\n}\n// docs:end:map\n\nimpl<K, T, Context, let N: u32> Storage<N> for Map<K, T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    // docs:start:new\n    pub fn new(\n        context: Context,\n        storage_slot: Field,\n        state_var_constructor: fn(Context, Field) -> V,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot, state_var_constructor }\n    }\n    // docs:end:new\n\n    // docs:start:at\n    pub fn at(self, key: K) -> V\n    where\n        K: ToField,\n    {\n        // TODO(#1204): use a generator index for the storage slot\n        let derived_storage_slot = derive_storage_slot_in_map(self.storage_slot, key);\n\n        let state_var_constructor = self.state_var_constructor;\n        state_var_constructor(self.context, derived_storage_slot)\n    }\n    // docs:end:at\n}\n"
     },
-    "177": {
+    "172": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/state_vars/public_mutable.nr",
       "source": "use crate::context::{PublicContext, UtilityContext};\nuse crate::state_vars::storage::Storage;\nuse dep::protocol_types::traits::Packable;\n\n// docs:start:public_mutable_struct\npub struct PublicMutable<T, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:public_mutable_struct\n\nimpl<T, Context, let N: u32> Storage<N> for PublicMutable<T, Context>\nwhere\n    T: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, Context> PublicMutable<T, Context> {\n    // docs:start:public_mutable_struct_new\n    pub fn new(\n        // Note: Passing the contexts to new(...) just to have an interface compatible with a Map.\n        context: Context,\n        storage_slot: Field,\n    ) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        PublicMutable { context, storage_slot }\n    }\n    // docs:end:public_mutable_struct_new\n}\n\nimpl<T> PublicMutable<T, &mut PublicContext> {\n    // docs:start:public_mutable_struct_read\n    pub fn read<let T_PACKED_LEN: u32>(self) -> T\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\n        self.context.storage_read(self.storage_slot)\n    }\n    // docs:end:public_mutable_struct_read\n\n    // docs:start:public_mutable_struct_write\n    pub fn write<let T_PACKED_LEN: u32>(self, value: T)\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\n        self.context.storage_write(self.storage_slot, value);\n    }\n    // docs:end:public_mutable_struct_write\n}\n\nimpl<T> PublicMutable<T, UtilityContext> {\n    pub unconstrained fn read<let T_PACKED_LEN: u32>(self) -> T\n    where\n        T: Packable<T_PACKED_LEN>,\n    {\n        self.context.storage_read(self.storage_slot)\n    }\n}\n"
     },
-    "24": {
+    "20": {
       "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub(crate) struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub(crate) fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub(crate) struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "267": {
+    "270": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "285": {
+    "288": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "302": {
+    "305": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "322": {
+    "325": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{hash::poseidon2_hash, traits::ToField};\n\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash([storage_slot, key.to_field()])\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x15b9fe39449affd8b377461263e9d2b610b9ad40580553500b4e41d9cbd887ac;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "340": {
+    "343": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
       "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable<BOOL_PACKED_LEN> for bool {\n    fn pack(self) -> [Field; BOOL_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; BOOL_PACKED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Packable<U8_PACKED_LEN> for u8 {\n    fn pack(self) -> [Field; U8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U8_PACKED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable<U16_PACKED_LEN> for u16 {\n    fn pack(self) -> [Field; U16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U16_PACKED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable<U32_PACKED_LEN> for u32 {\n    fn pack(self) -> [Field; U32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U32_PACKED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable<U64_PACKED_LEN> for u64 {\n    fn pack(self) -> [Field; U64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U64_PACKED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable<U128_PACKED_LEN> for u128 {\n    fn pack(self) -> [Field; U128_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; U128_PACKED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable<FIELD_PACKED_LEN> for Field {\n    fn pack(self) -> [Field; FIELD_PACKED_LEN] {\n        [self]\n    }\n\n    fn unpack(fields: [Field; FIELD_PACKED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable<I8_PACKED_LEN> for i8 {\n    fn pack(self) -> [Field; I8_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I8_PACKED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Packable<I16_PACKED_LEN> for i16 {\n    fn pack(self) -> [Field; I16_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I16_PACKED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Packable<I32_PACKED_LEN> for i32 {\n    fn pack(self) -> [Field; I32_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I32_PACKED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Packable<I64_PACKED_LEN> for i64 {\n    fn pack(self) -> [Field; I64_PACKED_LEN] {\n        [self as Field]\n    }\n\n    fn unpack(fields: [Field; I64_PACKED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Packable<N * M> for [T; N]\nwhere\n    T: Packable<M>,\n{\n    fn pack(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].pack();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    fn unpack(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
     },
-    "341": {
+    "344": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_serialization.nr",
       "source": "use crate::traits::{Deserialize, Serialize};\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize<BOOL_SERIALIZED_LEN> for bool {\n    fn serialize(self) -> [Field; BOOL_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<BOOL_SERIALIZED_LEN> for bool {\n    fn deserialize(fields: [Field; BOOL_SERIALIZED_LEN]) -> bool {\n        fields[0] as bool\n    }\n}\n\nimpl Serialize<U8_SERIALIZED_LEN> for u8 {\n    fn serialize(self) -> [Field; U8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U8_SERIALIZED_LEN> for u8 {\n    fn deserialize(fields: [Field; U8_SERIALIZED_LEN]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Serialize<U16_SERIALIZED_LEN> for u16 {\n    fn serialize(self) -> [Field; U16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U16_SERIALIZED_LEN> for u16 {\n    fn deserialize(fields: [Field; U16_SERIALIZED_LEN]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Serialize<U32_SERIALIZED_LEN> for u32 {\n    fn serialize(self) -> [Field; U32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U32_SERIALIZED_LEN> for u32 {\n    fn deserialize(fields: [Field; U32_SERIALIZED_LEN]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Serialize<U64_SERIALIZED_LEN> for u64 {\n    fn serialize(self) -> [Field; U64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U64_SERIALIZED_LEN> for u64 {\n    fn deserialize(fields: [Field; U64_SERIALIZED_LEN]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Serialize<U128_SERIALIZED_LEN> for u128 {\n    fn serialize(self) -> [Field; U128_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<U128_SERIALIZED_LEN> for u128 {\n    fn deserialize(fields: [Field; U128_SERIALIZED_LEN]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Serialize<FIELD_SERIALIZED_LEN> for Field {\n    fn serialize(self) -> [Field; FIELD_SERIALIZED_LEN] {\n        [self]\n    }\n}\n\nimpl Deserialize<FIELD_SERIALIZED_LEN> for Field {\n    fn deserialize(fields: [Field; FIELD_SERIALIZED_LEN]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Serialize<I8_SERIALIZED_LEN> for i8 {\n    fn serialize(self) -> [Field; I8_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I8_SERIALIZED_LEN> for i8 {\n    fn deserialize(fields: [Field; I8_SERIALIZED_LEN]) -> Self {\n        fields[0] as i8\n    }\n}\n\nimpl Serialize<I16_SERIALIZED_LEN> for i16 {\n    fn serialize(self) -> [Field; I16_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I16_SERIALIZED_LEN> for i16 {\n    fn deserialize(fields: [Field; I16_SERIALIZED_LEN]) -> Self {\n        fields[0] as i16\n    }\n}\n\nimpl Serialize<I32_SERIALIZED_LEN> for i32 {\n    fn serialize(self) -> [Field; I32_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I32_SERIALIZED_LEN> for i32 {\n    fn deserialize(fields: [Field; I32_SERIALIZED_LEN]) -> Self {\n        fields[0] as i32\n    }\n}\n\nimpl Serialize<I64_SERIALIZED_LEN> for i64 {\n    fn serialize(self) -> [Field; I64_SERIALIZED_LEN] {\n        [self as Field]\n    }\n}\n\nimpl Deserialize<I64_SERIALIZED_LEN> for i64 {\n    fn deserialize(fields: [Field; I64_SERIALIZED_LEN]) -> Self {\n        fields[0] as i64\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Serialize<N * M> for [T; N]\nwhere\n    T: Serialize<M>,\n{\n    fn serialize(self) -> [Field; N * M] {\n        let mut result: [Field; N * M] = std::mem::zeroed();\n        let mut serialized: [Field; M] = std::mem::zeroed();\n        for i in 0..N {\n            serialized = self[i].serialize();\n            for j in 0..M {\n                result[i * M + j] = serialized[j];\n            }\n        }\n        result\n    }\n}\n\nimpl<T, let N: u32, let M: u32> Deserialize<N * M> for [T; N]\nwhere\n    T: Deserialize<M>,\n{\n    fn deserialize(fields: [Field; N * M]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let mut result: [T; N] = std::mem::zeroed();\n        reader.read_struct_array::<T, M, N>(Deserialize::deserialize, result)\n    }\n}\n\n#[test]\nfn test_u16_serialization() {\n    let a: u16 = 10;\n    assert_eq(a, u16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i8_serialization() {\n    let a: i8 = -10;\n    assert_eq(a, i8::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i16_serialization() {\n    let a: i16 = -10;\n    assert_eq(a, i16::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i32_serialization() {\n    let a: i32 = -10;\n    assert_eq(a, i32::deserialize(a.serialize()));\n}\n\n#[test]\nfn test_i64_serialization() {\n    let a: i64 = -10;\n    assert_eq(a, i64::deserialize(a.serialize()));\n}\n"
     },
-    "357": {
+    "360": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
       "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    // Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    // of the element and non-emptiness of the previous element is checked below.\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n/// This function assumes that `array1` and `array2` contain no more than N non-empty elements between them,\n/// if this is not the case then elements from the end of `array2` will be dropped.\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    // Safety: we constrain this array below\n    let result = unsafe { array_merge_helper(array1, array2) };\n    // We assume arrays have been validated. The only use cases so far are with previously validated arrays.\n    let array1_len = array_length(array1);\n    let mut add_from_left = true;\n    for i in 0..N {\n        add_from_left &= i != array1_len;\n        if add_from_left {\n            assert_eq(result[i], array1[i]);\n        } else {\n            assert_eq(result[i], array2[i - array1_len]);\n        }\n    }\n    result\n}\n\nunconstrained fn array_merge_helper<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n// Helper function to find the index of the last element in an array, allowing empty elements.\n// e.g. useful for removing trailing 0s from [1, 0, 2, 0, 0, 0] -> [1, 0, 2]\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn find_last_value_index<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut index = N;\n    for i in 0..N {\n        let j = N - i - 1;\n        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\n        if (index == N) & !is_empty(array[j]) {\n            index = j;\n        }\n    }\n    index\n}\n\n// Routine which returns the length of an array right padded by empty elements\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\n// See smoke_validate_array_trailing for examples.\n// Nothing to do with validated arrays. Correctness constrained by padded_array_length.\npub unconstrained fn unsafe_padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let index = find_last_value_index(array);\n    if index == N {\n        0\n    } else {\n        index + 1\n    }\n}\n\n// Routine which validates that zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where * is any value (zeroes allowed).\npub fn padded_array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // Safety: this value is constrained in the below loop.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    // Check the elt just before length is non-zero:\n    if length != 0 {\n        assert(!is_empty(array[length - 1]), \"invalid right padded array\");\n    }\n    // Check all beyond length are zero:\n    let mut check_zero = false;\n    for i in 0..N {\n        check_zero |= i == length;\n        if check_zero {\n            assert(is_empty(array[i]), \"invalid right padded array\");\n        }\n    }\n    length\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test]\nfn smoke_validate_array_trailing() {\n    let valid_array: [Field; 0] = [];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(padded_array_length(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(padded_array_length(valid_array) == 1);\n\n    let valid_array = [1, 0, 3];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 0, 3, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n\n    let valid_array = [0, 0, 3, 0, 0];\n    assert(padded_array_length(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
-    "360": {
+    "363": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "47": {
+    "43": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "54": {
+    "50": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/auth_registry_contract/src/main.nr",
       "source": "/**\n * @title AuthRegistry Contract\n * @notice Manages authorization of public actions through authentication witnesses (authwits)\n * @dev This contract allows users to approve/reject public actions that can be performed on their behalf by other\n * addresses\n */\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract AuthRegistry {\n    use dep::authwit::auth::{\n        assert_current_call_valid_authwit, compute_authwit_message_hash, IS_VALID_SELECTOR,\n    };\n    use dep::aztec::{\n        macros::{functions::{internal, private, public, utility, view}, storage::storage},\n        protocol_types::address::AztecAddress,\n        state_vars::{Map, PublicMutable},\n    };\n\n    #[storage]\n    struct Storage<Context> {\n        /// Map of addresses that have rejected all actions\n        reject_all: Map<AztecAddress, PublicMutable<bool, Context>, Context>,\n        /// Nested map of approvers to their authorized message hashes\n        /// First key is the approver address, second key is the message hash, value is authorization status\n        approved_actions: Map<AztecAddress, Map<Field, PublicMutable<bool, Context>, Context>, Context>,\n    }\n\n    /**\n     * Updates the `authorized` value for `msg_sender` for `message_hash`.\n     *\n     * @param message_hash The message hash being authorized\n     * @param authorize True if the caller is authorized to perform the message hash, false otherwise\n     */\n    #[public]\n    fn set_authorized(message_hash: Field, authorize: bool) {\n        storage.approved_actions.at(context.msg_sender()).at(message_hash).write(authorize);\n    }\n\n    /**\n     * Updates the `reject_all` value for `msg_sender`.\n     *\n     * When `reject_all` is `true` any `consume` on `msg_sender` will revert.\n     *\n     * @param reject True if all actions should be rejected, false otherwise\n     */\n    #[public]\n    fn set_reject_all(reject: bool) {\n        storage.reject_all.at(context.msg_sender()).write(reject);\n    }\n\n    /**\n     * Consumes an `inner_hash` on behalf of `on_behalf_of` if the caller is authorized to do so.\n     *\n     * Will revert even if the caller is authorized if `reject_all` is set to true for `on_behalf_of`.\n     * This is to support \"mass-revoke\".\n     *\n     * @param on_behalf_of The address on whose behalf the action is being consumed\n     * @param inner_hash The inner_hash of the authwit\n     * @return `IS_VALID_SELECTOR` if the action was consumed, revert otherwise\n     */\n    #[public]\n    fn consume(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n        assert_eq(false, storage.reject_all.at(on_behalf_of).read(), \"rejecting all\");\n\n        let message_hash = compute_authwit_message_hash(\n            context.msg_sender(),\n            context.chain_id(),\n            context.version(),\n            inner_hash,\n        );\n\n        let authorized = storage.approved_actions.at(on_behalf_of).at(message_hash).read();\n\n        assert_eq(true, authorized, \"unauthorized\");\n        storage.approved_actions.at(on_behalf_of).at(message_hash).write(false);\n\n        IS_VALID_SELECTOR\n    }\n\n    /**\n     * Updates a public authwit using a private authwit\n     *\n     * Useful for the case where you want someone else to insert a public authwit for you.\n     * For example, if Alice wants Bob to insert an authwit in public, such that they can execute\n     * a trade, Alice can create a private authwit, and Bob can call this function with it.\n     *\n     * @param approver The address of the approver (Alice in the example)\n     * @param message_hash The message hash to authorize\n     * @param authorize True if the message hash should be authorized, false otherwise\n     */\n    #[private]\n    fn set_authorized_private(approver: AztecAddress, message_hash: Field, authorize: bool) {\n        assert_current_call_valid_authwit(&mut context, approver);\n        AuthRegistry::at(context.this_address())\n            ._set_authorized(approver, message_hash, authorize)\n            .enqueue(&mut context);\n    }\n\n    /**\n     * Internal function to update the `authorized` value for `approver` for `messageHash`.\n     * Used along with `set_authorized_private` to update the public authwit.\n     *\n     * @param approver The address of the approver\n     * @param message_hash The message hash being authorized\n     * @param authorize True if the caller is authorized to perform the message hash, false otherwise\n     */\n    #[public]\n    #[internal]\n    fn _set_authorized(approver: AztecAddress, message_hash: Field, authorize: bool) {\n        storage.approved_actions.at(approver).at(message_hash).write(authorize);\n    }\n\n    /**\n     * Fetches the `reject_all` value for `on_behalf_of`.\n     *\n     * @param on_behalf_of The address to check\n     * @return True if all actions are rejected, false otherwise\n     */\n    #[public]\n    #[view]\n    fn is_reject_all(on_behalf_of: AztecAddress) -> bool {\n        storage.reject_all.at(on_behalf_of).read()\n    }\n\n    /**\n     * Fetches the `authorized` value for `on_behalf_of` for `message_hash`.\n     *\n     * @param on_behalf_of The address on whose behalf the action is being consumed\n     * @param message_hash The message hash to check\n     * @return True if the caller is authorized to perform the action, false otherwise\n     */\n    #[public]\n    #[view]\n    fn is_consumable(on_behalf_of: AztecAddress, message_hash: Field) -> bool {\n        storage.approved_actions.at(on_behalf_of).at(message_hash).read()\n    }\n\n    /**\n     * Just like `is_consumable`, but a utility function and not public.\n     */\n    #[utility]\n    unconstrained fn utility_is_consumable(\n        on_behalf_of: AztecAddress,\n        message_hash: Field,\n    ) -> bool {\n        storage.approved_actions.at(on_behalf_of).at(message_hash).read()\n    }\n}\n"
     },
-    "56": {
+    "52": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/auth.nr",
       "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n    traits::ToField,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\npub global IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .get_preimage();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
     },
-    "65": {
+    "61": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    traits::{Deserialize, ToField},\n};\n\nuse crate::context::{gas::GasOpts, private_context::PrivateContext, public_context::PublicContext};\n\nuse crate::hash::{hash_args, hash_calldata};\nuse crate::oracle::execution_cache;\n\npub trait CallInterface<let N: u32> {\n    fn get_args(self) -> [Field];\n    fn get_selector(self) -> FunctionSelector;\n    fn get_name(self) -> str<N>;\n    fn get_contract_address(self) -> AztecAddress;\n    fn get_is_static(self) -> bool;\n}\n\n// PrivateCallInterface\n\npub struct PrivateCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn call<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            false,\n        );\n        let returns: T = returns_hash.get_preimage();\n        returns\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns_hash = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns_hash.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateVoidCallInterface\n\npub struct PrivateVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static }\n    }\n\n    pub fn call(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                false,\n            )\n            .assert_empty();\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticCallInterface\n\npub struct PrivateStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PrivateStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self {\n            target_contract,\n            selector,\n            name,\n            args_hash,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n        }\n    }\n\n    pub fn view<let M: u32>(self, context: &mut PrivateContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        execution_cache::store(self.args, self.args_hash);\n        let returns = context.call_private_function_with_args_hash(\n            self.target_contract,\n            self.selector,\n            self.args_hash,\n            true,\n        );\n        returns.get_preimage()\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PrivateStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PrivateStaticVoidCallInterface\n\npub struct PrivateStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args_hash: Field,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n}\n\nimpl<let N: u32> PrivateStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        let args_hash = hash_args(args);\n        Self { target_contract, selector, name, args_hash, args, return_type: (), is_static: true }\n    }\n\n    pub fn view(self, context: &mut PrivateContext) {\n        execution_cache::store(self.args, self.args_hash);\n        context\n            .call_private_function_with_args_hash(\n                self.target_contract,\n                self.selector,\n                self.args_hash,\n                true,\n            )\n            .assert_empty();\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PrivateStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicCallInterface\n\npub struct PublicCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    gas_opts: GasOpts,\n    return_type: T,\n    is_static: bool,\n}\n\nimpl<let N: u32, T> PublicCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            gas_opts: GasOpts::default(),\n            return_type: std::mem::zeroed(),\n            is_static,\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicVoidCallInterface\n\npub struct PublicVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n        is_static: bool,\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn call(self, context: &mut PublicContext) {\n        let returns = context.call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            false,\n        )\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n\n    pub fn set_as_teardown(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.set_public_teardown_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            false,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticCallInterface\n\npub struct PublicStaticCallInterface<let N: u32, T> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: T,\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32, T> PublicStaticCallInterface<N, T> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: std::mem::zeroed(),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view<let M: u32>(self, context: &mut PublicContext) -> T\n    where\n        T: Deserialize<M>,\n    {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        Deserialize::deserialize(returns.as_array::<M>())\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32, T> CallInterface<N> for PublicStaticCallInterface<N, T> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n\n// PublicStaticVoidCallInterface\n\npub struct PublicStaticVoidCallInterface<let N: u32> {\n    target_contract: AztecAddress,\n    selector: FunctionSelector,\n    name: str<N>,\n    args: [Field],\n    return_type: (), // Unit type () indicates this interface is for functions that return nothing (void)\n    is_static: bool,\n    gas_opts: GasOpts,\n}\n\nimpl<let N: u32> PublicStaticVoidCallInterface<N> {\n    pub fn new(\n        target_contract: AztecAddress,\n        selector: FunctionSelector,\n        name: str<N>,\n        args: [Field],\n    ) -> Self {\n        Self {\n            target_contract,\n            selector,\n            name,\n            args,\n            return_type: (),\n            is_static: true,\n            gas_opts: GasOpts::default(),\n        }\n    }\n\n    pub fn with_gas(self: &mut Self, gas_opts: GasOpts) -> &mut Self {\n        self.gas_opts = gas_opts;\n        self\n    }\n\n    pub unconstrained fn view(self, context: &mut PublicContext) {\n        let returns = context.static_call_public_function(\n            self.target_contract,\n            self.selector,\n            self.args,\n            self.gas_opts,\n        );\n        assert(returns.len() == 0);\n    }\n\n    pub fn enqueue_view(self, context: &mut PrivateContext) {\n        let calldata = self.args.push_front(self.selector.to_field());\n        let calldata_hash = hash_calldata(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        context.call_public_function_with_calldata_hash(\n            self.target_contract,\n            calldata_hash,\n            /*static=*/\n            true,\n        )\n    }\n}\n\nimpl<let N: u32> CallInterface<N> for PublicStaticVoidCallInterface<N> {\n    fn get_args(self) -> [Field] {\n        self.args\n    }\n\n    fn get_selector(self) -> FunctionSelector {\n        self.selector\n    }\n\n    fn get_name(self) -> str<N> {\n        self.name\n    }\n\n    fn get_contract_address(self) -> AztecAddress {\n        self.target_contract\n    }\n\n    fn get_is_static(self) -> bool {\n        self.is_static\n    }\n}\n"
     },
-    "72": {
+    "68": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array, hash_calldata_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            notify_enqueued_public_function_call, notify_set_min_revertible_side_effect_counter,\n            notify_set_public_teardown_function_call,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, Hash, ToField},\n    utils::arrays::array_concat,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        self.return_hash = returns_hasher.hash();\n        execution_cache::store(returns_hasher.fields, self.return_hash);\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request = self.last_key_validation_requests[key_index as u32].unwrap_or(\n            KeyValidationRequest::empty(),\n        );\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index as u32],\n                },\n            );\n            self.last_key_validation_requests[key_index as u32] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        let calldata_hash = hash_calldata_array([function_selector.to_field()]);\n        self.call_public_function_with_calldata_hash(contract_address, calldata_hash, true)\n    }\n\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_enqueued_public_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let calldata = array_concat([function_selector.to_field()], args);\n        let calldata_hash = hash_calldata_array(calldata);\n        execution_cache::store(calldata, calldata_hash);\n        self.set_public_teardown_function_with_calldata_hash(contract_address, calldata_hash, false)\n    }\n\n    pub fn set_public_teardown_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        notify_set_public_teardown_function_call(\n            contract_address,\n            calldata_hash,\n            counter,\n            is_static_call,\n        );\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            is_static_call,\n            calldata_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "73": {
+    "69": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/public_context.nr",
       "source": "use crate::context::gas::GasOpts;\nuse crate::hash::{\n    compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n};\nuse dep::protocol_types::abis::function_selector::FunctionSelector;\nuse dep::protocol_types::address::{AztecAddress, EthAddress};\nuse dep::protocol_types::constants::MAX_FIELD_VALUE;\nuse dep::protocol_types::traits::{Empty, FromField, Packable, Serialize, ToField};\n\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    pub fn emit_public_log<T, let N: u32>(_self: &mut Self, log: T)\n    where\n        T: Serialize<N>,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_public_log(Serialize::serialize(log).as_slice()) };\n    }\n\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { note_hash_exists(note_hash, leaf_index) } == 1\n    }\n\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { l1_to_l2_msg_exists(msg_hash, msg_leaf_index) } == 1\n    }\n\n    pub fn nullifier_exists(_self: Self, unsiloed_nullifier: Field, address: AztecAddress) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { nullifier_exists(unsiloed_nullifier, address.to_field()) } == 1\n    }\n\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    pub fn message_portal(_self: &mut Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { send_l2_to_l1_msg(recipient, content) };\n    }\n\n    pub unconstrained fn call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub unconstrained fn static_call_public_function(\n        _self: &mut Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = args.push_front(function_selector.to_field());\n\n        call_static(gas_for_call(gas_opts), contract_address, calldata);\n        // Use success_copy to determine whether the call succeeded\n        let success = success_copy();\n\n        let result_data = returndata_copy(0, returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm_revert(result_data);\n        }\n        result_data\n    }\n\n    pub fn push_note_hash(_self: &mut Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_note_hash(note_hash) };\n    }\n    pub fn push_nullifier(_self: &mut Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { emit_nullifier(nullifier) };\n    }\n\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            address()\n        }\n    }\n    pub fn msg_sender(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            sender()\n        }\n    }\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let raw_selector: [Field; 1] = unsafe { calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            transaction_fee()\n        }\n    }\n\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            chain_id()\n        }\n    }\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            version()\n        }\n    }\n    pub fn block_number(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            block_number()\n        }\n    }\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            timestamp()\n        }\n    }\n    pub fn fee_per_l2_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_l2_gas()\n        }\n    }\n    pub fn fee_per_da_gas(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            fee_per_da_gas()\n        }\n    }\n\n    pub fn l2_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            l2_gas_left()\n        }\n    }\n    pub fn da_gas_left(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            da_gas_left()\n        }\n    }\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { is_static_call() } == 1\n    }\n\n    pub fn raw_storage_read<let N: u32>(_self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe { storage_read(storage_slot + i as Field) };\n        }\n        out\n    }\n\n    pub fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    pub fn storage_write<T, let N: u32>(self, storage_slot: Field, value: T)\n    where\n        T: Packable<N>,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\n// Helper functions\nfn gas_for_call(user_gas: GasOpts) -> [Field; 2] {\n    // It's ok to use the max possible gas here, because the gas will be\n    // capped by the gas left in the (STATIC)CALL instruction.\n    [user_gas.l2_gas.unwrap_or(MAX_FIELD_VALUE), user_gas.da_gas.unwrap_or(MAX_FIELD_VALUE)]\n}\n\n// Unconstrained opcode wrappers (do not use directly).\nunconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\nunconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\nunconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\nunconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\nunconstrained fn version() -> Field {\n    version_opcode()\n}\nunconstrained fn block_number() -> Field {\n    block_number_opcode()\n}\nunconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\nunconstrained fn fee_per_l2_gas() -> Field {\n    fee_per_l2_gas_opcode()\n}\nunconstrained fn fee_per_da_gas() -> Field {\n    fee_per_da_gas_opcode()\n}\nunconstrained fn l2_gas_left() -> Field {\n    l2_gas_left_opcode()\n}\nunconstrained fn da_gas_left() -> Field {\n    da_gas_left_opcode()\n}\nunconstrained fn is_static_call() -> Field {\n    is_static_call_opcode()\n}\nunconstrained fn note_hash_exists(note_hash: Field, leaf_index: Field) -> u1 {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\nunconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\nunconstrained fn nullifier_exists(nullifier: Field, address: Field) -> u1 {\n    nullifier_exists_opcode(nullifier, address)\n}\nunconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\nunconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\nunconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: Field) -> u1 {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\nunconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\nunconstrained fn call(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_opcode(gas, address, args)\n}\n\nunconstrained fn call_static(gas: [Field; 2], address: AztecAddress, args: [Field]) {\n    call_static_opcode(gas, address, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n// `success_copy` is placed immediately after the CALL opcode to get the success value\nunconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\nunconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\nunconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\nunconstrained fn avm_revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\nunconstrained fn storage_read(storage_slot: Field) -> Field {\n    storage_read_opcode(storage_slot)\n}\n\nunconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n\n// AVM oracles (opcodes) follow, do not use directly.\n#[oracle(avmOpcodeAddress)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeSender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(avmOpcodeTransactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(avmOpcodeChainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(avmOpcodeVersion)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(avmOpcodeBlockNumber)]\nunconstrained fn block_number_opcode() -> Field {}\n\n#[oracle(avmOpcodeTimestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(avmOpcodeFeePerL2Gas)]\nunconstrained fn fee_per_l2_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeFeePerDaGas)]\nunconstrained fn fee_per_da_gas_opcode() -> Field {}\n\n#[oracle(avmOpcodeL2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeDaGasLeft)]\nunconstrained fn da_gas_left_opcode() -> Field {}\n\n#[oracle(avmOpcodeIsStaticCall)]\nunconstrained fn is_static_call_opcode() -> Field {}\n\n#[oracle(avmOpcodeNoteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(avmOpcodeNullifierExists)]\nunconstrained fn nullifier_exists_opcode(nullifier: Field, address: Field) -> u1 {}\n\n#[oracle(avmOpcodeEmitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n// TODO(#11124): rename unencrypted to public in avm\n#[oracle(avmOpcodeEmitUnencryptedLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(avmOpcodeL1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: Field) -> u1 {}\n\n#[oracle(avmOpcodeSendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(avmOpcodeCalldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(avmOpcodeReturndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(avmOpcodeReturndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(avmOpcodeReturn)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n// This opcode reverts using the exact data given. In general it should only be used\n// to do rethrows, where the revert data is the same as the original revert data.\n// For normal reverts, use Noir's `assert` which, on top of reverting, will also add\n// an error selector to the revert data.\n#[oracle(avmOpcodeRevert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n#[oracle(avmOpcodeCall)]\nunconstrained fn call_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeStaticCall)]\nunconstrained fn call_static_opcode(\n    gas: [Field; 2], // gas allocation: [l2_gas, da_gas]\n    address: AztecAddress,\n    args: [Field],\n) {}\n\n#[oracle(avmOpcodeSuccessCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(avmOpcodeStorageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field) -> Field {}\n\n#[oracle(avmOpcodeStorageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "74": {
+    "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/returns_hash.nr",
       "source": "use crate::{hash::hash_args_array, oracle::execution_cache};\nuse dep::protocol_types::traits::Deserialize;\n\npub struct ReturnsHash {\n    hash: Field,\n}\n\nimpl ReturnsHash {\n    pub fn new(hash: Field) -> Self {\n        ReturnsHash { hash }\n    }\n\n    pub fn assert_empty(self) {\n        assert_eq(self.hash, 0);\n    }\n\n    pub fn raw(self) -> Field {\n        self.hash\n    }\n\n    /// This is only used during private execution, since in public it is the VM itself that keeps track of return\n    /// values.\n    pub fn get_preimage<T, let N: u32>(self) -> T\n    where\n        T: Deserialize<N>,\n    {\n        // Safety: We verify that the value returned by `load` is the preimage of `hash`, fully constraining it.\n        let preimage: [Field; N] = unsafe { execution_cache::load(self.hash) };\n        assert_eq(self.hash, hash_args_array(preimage));\n\n        Deserialize::deserialize(preimage)\n    }\n}\n"
     },
-    "75": {
+    "71": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/utility_context.nr",
       "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Packable};\n\npub struct UtilityContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UtilityContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create a UtilityContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "98": {
+    "75": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__PUBLIC_CALLDATA, GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Same as `hash_args_array`, but takes a slice instead of an array.\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
+    },
+    "97": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
+      "source": "use super::utils::compute_fn_selector;\nuse std::panic;\n\n/// Returns an `fn public_dispatch(...)` function for the given module that's assumed to be an Aztec contract.\npub comptime fn generate_public_dispatch(m: Module) -> Quoted {\n    let functions = m.functions();\n    let functions =\n        functions.filter(|function: FunctionDefinition| function.has_named_attribute(\"public\"));\n\n    let unit = get_type::<()>();\n\n    let ifs = functions.map(|function: FunctionDefinition| {\n        let parameters = function.parameters();\n        let return_type = function.return_type();\n\n        let selector: Field = compute_fn_selector(function);\n\n        let mut parameters_size = 0;\n        for param in parameters {\n            parameters_size += size_in_fields(param.1);\n        }\n\n        let initial_read = if parameters.len() == 0 {\n            quote {}\n        } else {\n            // The initial calldata_copy offset is 1 to skip the Field selector\n            // The expected calldata is the serialization of\n            // - FunctionSelector: the selector of the function intended to dispatch\n            // - Parameters: the parameters of the function intended to dispatch\n            // That is, exactly what is expected for a call to the target function,\n            // but with a selector added at the beginning.\n            quote {\n                let input_calldata: [Field; $parameters_size] = dep::aztec::context::public_context::calldata_copy(1, $parameters_size);\n                let mut reader = dep::aztec::protocol_types::utils::reader::Reader::new(input_calldata);\n            }\n        };\n\n        let parameter_index = &mut 0;\n        let reads = parameters.map(|param: (Quoted, Type)| {\n            let parameter_index_value = *parameter_index;\n            let param_name = f\"arg{parameter_index_value}\".quoted_contents();\n            let param_type = param.1;\n            let read = quote {\n                let $param_name: $param_type = reader.read_struct(dep::aztec::protocol_types::traits::Deserialize::deserialize);\n            };\n            *parameter_index += 1;\n            quote { $read }\n        });\n        let read = reads.join(quote { });\n\n        let mut args = &[];\n        for parameter_index in 0..parameters.len() {\n            let param_name = f\"arg{parameter_index}\".quoted_contents();\n            args = args.push_back(quote { $param_name });\n        }\n\n        let args = args.join(quote { , });\n        // name of the function is assigned just before the call so debug metadata doesn't span most of this macro when figuring out where the call comes from.\n        let name = function.name();\n        let call = quote { $name($args) };\n\n        let return_code = if return_type == unit {\n            quote {\n                $call;\n                // Force early return.\n                dep::aztec::context::public_context::avm_return([]);\n            }\n        } else {\n            quote {\n                let return_value = dep::aztec::protocol_types::traits::Serialize::serialize($call);\n                dep::aztec::context::public_context::avm_return(return_value.as_slice());\n            }\n        };\n\n        let if_ = quote {\n            if selector == $selector {\n                $initial_read\n                $read\n                $return_code\n            }\n        };\n        if_\n    });\n\n    if ifs.len() == 0 {\n        // No dispatch function if there are no public functions\n        quote {}\n    } else {\n        let ifs = ifs.push_back(quote { panic(f\"Unknown selector {selector}\") });\n        let dispatch = ifs.join(quote {  });\n\n        let body = quote {\n            // We mark this as public because our whole system depends on public\n            // functions having this attribute. However, the public MACRO will\n            // handle the public_dispatch function specially and do nothing.\n            #[public]\n            pub unconstrained fn public_dispatch(selector: Field) {\n                $dispatch\n            }\n        };\n\n        body\n    }\n}\n\ncomptime fn size_in_fields(typ: Type) -> u32 {\n    let size = array_size_in_fields(typ);\n    let size = size.or_else(|| bool_size_in_fields(typ));\n    let size = size.or_else(|| constant_size_in_fields(typ));\n    let size = size.or_else(|| field_size_in_fields(typ));\n    let size = size.or_else(|| int_size_in_fields(typ));\n    let size = size.or_else(|| str_size_in_fields(typ));\n    let size = size.or_else(|| struct_size_in_fields(typ));\n    let size = size.or_else(|| tuple_size_in_fields(typ));\n    if size.is_some() {\n        size.unwrap()\n    } else {\n        panic(f\"Can't determine size in fields of {typ}\")\n    }\n}\n\ncomptime fn array_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_array().and_then(|typ: (Type, Type)| {\n        let (typ, element_size) = typ;\n        element_size.as_constant().map(|x: u32| x * size_in_fields(typ))\n    })\n}\n\ncomptime fn bool_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_bool() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn field_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.is_field() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn int_size_in_fields(typ: Type) -> Option<u32> {\n    if typ.as_integer().is_some() {\n        Option::some(1)\n    } else {\n        Option::none()\n    }\n}\n\ncomptime fn constant_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_constant()\n}\n\ncomptime fn str_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_str().map(|typ| size_in_fields(typ))\n}\n\ncomptime fn struct_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_data_type().map(|typ: (TypeDefinition, [Type])| {\n        let struct_type = typ.0;\n        let generics = typ.1;\n        let mut size = 0;\n        for field in struct_type.fields(generics) {\n            size += size_in_fields(field.1);\n        }\n        size\n    })\n}\n\ncomptime fn tuple_size_in_fields(typ: Type) -> Option<u32> {\n    typ.as_tuple().map(|types: [Type]| {\n        let mut size = 0;\n        for typ in types {\n            size += size_in_fields(typ);\n        }\n        size\n    })\n}\n\ncomptime fn get_type<T>() -> Type {\n    let t: T = std::mem::zeroed();\n    std::meta::type_of(t)\n}\n"
     }
   }
 }