@aztec/protocol-contracts 0.83.1 → 0.84.0

package/artifacts/Router.json

@@ -3,249 +3,6 @@
   "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
   "name": "Router",
   "functions": [
-    {
-      "name": "public_dispatch",
-      "is_unconstrained": true,
-      "custom_attributes": [
-        "public"
-      ],
-      "abi": {
-        "parameters": [
-          {
-            "name": "selector",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null,
-        "error_types": {
-          "1433889167918961673": {
-            "error_kind": "fmtstring",
-            "length": 17,
-            "item_types": []
-          },
-          "2242946026394210301": {
-            "error_kind": "string",
-            "string": "Block number mismatch."
-          },
-          "2830029349304997821": {
-            "error_kind": "fmtstring",
-            "length": 27,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "8209322232883590150": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called internally"
-          },
-          "8443716675528357851": {
-            "error_kind": "string",
-            "string": "Timestamp mismatch."
-          },
-          "10421965853029650238": {
-            "error_kind": "string",
-            "string": "Function _check_block_number can only be called statically"
-          },
-          "11405868724477732285": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called internally"
-          },
-          "13418685691864489983": {
-            "error_kind": "string",
-            "string": "Function _check_timestamp can only be called statically"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "public_dispatch"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "576755928210959028": {
-            "error_kind": "string",
-            "string": "0 has a square root; you cannot claim it is not square"
-          },
-          "2588366281349374274": {
-            "error_kind": "fmtstring",
-            "length": 136,
-            "item_types": [
-              {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            ]
-          },
-          "2709101749560550278": {
-            "error_kind": "string",
-            "string": "Cannot serialize point at infinity as bytes."
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "3305101268118424981": {
-            "error_kind": "string",
-            "string": "Attempted to delete past the length of a CapsuleArray"
-          },
-          "3367683922240523006": {
-            "error_kind": "fmtstring",
-            "length": 58,
-            "item_types": [
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "3473764466780631008": {
-            "error_kind": "fmtstring",
-            "length": 106,
-            "item_types": [
-              {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            ]
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "5533887251808526417": {
-            "error_kind": "fmtstring",
-            "length": 120,
-            "item_types": [
-              {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            ]
-          },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "5870202753060865374": {
-            "error_kind": "fmtstring",
-            "length": 61,
-            "item_types": [
-              {
-                "kind": "field"
-              },
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "6485997221020871071": {
-            "error_kind": "string",
-            "string": "call to assert_max_bit_size"
-          },
-          "6753155520859132764": {
-            "error_kind": "string",
-            "string": "Failed to deliver note"
-          },
-          "7233212735005103307": {
-            "error_kind": "string",
-            "string": "attempt to multiply with overflow"
-          },
-          "8830323656616886390": {
-            "error_kind": "string",
-            "string": "Got a public log emitted by a different contract"
-          },
-          "12099279057757775880": {
-            "error_kind": "string",
-            "string": "DST_LEN too large for offset"
-          },
-          "13649294680379557736": {
-            "error_kind": "string",
-            "string": "extend_from_bounded_vec out of bounds"
-          },
-          "14225679739041873922": {
-            "error_kind": "string",
-            "string": "Index out of bounds"
-          },
-          "14514982005979867414": {
-            "error_kind": "string",
-            "string": "attempt to bit-shift with overflow"
-          },
-          "14657895983200220173": {
-            "error_kind": "string",
-            "string": "Attempted to read past the length of a CapsuleArray"
-          },
-          "15366650908120444287": {
-            "error_kind": "fmtstring",
-            "length": 48,
-            "item_types": [
-              {
-                "kind": "field"
-              },
-              {
-                "kind": "field"
-              }
-            ]
-          },
-          "16218014537381711836": {
-            "error_kind": "string",
-            "string": "Value does not fit in field"
-          },
-          "16446004518090376065": {
-            "error_kind": "string",
-            "string": "Input length must be a multiple of 32"
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "length": 40,
-            "item_types": []
-          },
-          "16954218183513903507": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/+29C5hcV3UueKqruqUuqdWlh23J8gsbY7AD1Ku7qxMIAtsEY8LLvN/VVdW2kW0ZvayHJZ1utSSbRyA4CSEhTyDhFUgIEAIkAS53br57k8nNlzBfvi/3Tu7MfHyTDN9khpk7M5mbmcno2Ged+uuvdXad6lpbKlva3yf1qbP3/tfaa6+19tr77LNPLuimXPy3EIyQBGT31U/9nY5/T0B+/vy/PfHv8mipMk10LfEb5UZjWmmfIf+16Rgz5we/LPie5F/eEOM8FnbxsS1Cd+P5f5vguhN09cNX+6X/fLZ/u6PNoju3h0GSunQrtcZ8rdqYr1bbnXKzPb+wvFhbKNeW5mqLraVKuTZXbbQXmrVyuVPrtOrl9vziXLvTXJyrLS81F+cF+w4Vu9ZZOg8115xvLFWWm/PL5aX6QqPWXF5YaDfbi/XOwly5XWnNV1rVynKj0Zyba7bmFiuV5c7i3HIjwb4z9CKzquC/HPALga3OR+mn/OAnPucVfvAT+dzlR/4J/6/0gl9J5H+3H/7rgv8qP/g1wf/pGD8A7EqjVq0u1BYXyouNdrlSb7eqjfMWvFQvt8rNVrWzWK8sLter9Vqr3Vpq1BvNynJ5udlaXG48BS7Yr1awy8OlCt8Q7NeAXHJmcqklfuG1o/POaU6wX5eOvW7RC/brFexqs9YqLy6Xm3ON5kKnMXfe3ZbPXyw1Osvz1ebSecdbbVcqlU79/H/VTru+uNSeryzNdxaqc0vnySUyvwdkbmhLLcF/gzH+fLO82JmfXxD8NxrjLy3NLzTPy1Pw32SMX2vNd5ZrC4mvfLMxfnOuvrw8V2sK/luM8ecq5c5cdSHRzbca4y8ulefmG41Ef95mjH8+bqi1F5tLgv92a/ksdcqtdmVxJsZ5R4wvNKIktN9pTDtOizmiF8T4fE/oF4lX63E7R/SQH5SPxJ8iu3eF/byWlDz0MZyXV+4JHQ3rjYZYbzLEerMh1lsMsd5qiPU2Qyyxa7+2Vk/G0Xd5wa8l8/h3e8EvdwT/PT7wK93Yrgn4gR3/Cf6SH/kk+K0Y3wfvbT+ySeZLHXveE+xle+xknnRv6KVPk7H/Pj/4Sexyvx/8tuC/1wt+JZHPXsC3m49VE71/wAt+LcF/0A9+ovsPecGvJ/j7/OAn9vWwH/xkvv0+L/hzCf/7/eAnc5sDXvDnk/496Ac/WQc65Ac/kf9hP/jJ3PsRP/iJfh7xg5+sTRz1g5/EhMf84C8K/nE/+Mn4+Kgf/GR8POEHP4mZT/rBT/zPKS/4C8n4GPrBT9a2VvzgJ/5t1Q9+4t9O+8FP/NuaH/zEv53xg5/4h7N+8JP485wf/Hb0PDd6lvvN7U/hbT7/b0uMfW/n4Mse2Nfa++pDDy519uNqmXARBL2raBJ9c4pQt3VRb9/30MH9zdbBl7bb+zsHDjDChIIcpKAWAfW+5v0P3dVO42dItDd19h+4f99DjFbIiCbPrCehvGFcVp6J8aaIP6S9gaRgQ7vSzrKmivSLxKuPNVWkJ/ywfHBNNcrbqPBaUvK4DzcqdDYqdEpKHseJo2CFhliPGGKdNMSybOOjhljHDLFOGGIdMcTaa4hlKXtLG1oZU6wDhliWOmEpe0v9OmSIZWnbljpx0BDL0kevGWKN6/h4JsbyG1uVGzMKbUmSh/tlMabixJE48h3hf2d7F5fLSdoM9A4cfaj16n0HOwcCR4UoyWZJvj9uwuOAsJihDUEwWLDfzyBYDuCRtxnCxLo5BUub4rAyo8ynUnhADOkrDIQNJxG1LO1A+hdqEqE5CW0SIfKZ9iOfao7wkZ9pRT6sw9x30T/ZvD0JWFgeN/pjebyW+njvT+O/paDfjuRhcU7Jyyv3RL6RzL9LbcO+YT310w/1SlY9FfrFwKfddPVU0wttMJsO+vvZctNHln7VfNsmJU+wNse/UU+xfBHaiOXxWurjvf8m/lsK+nWa9XST0h68h3r67+Pr6ZT27Il/l0dKCwvaOMV2gHKy3MSa1Q6EfjHwqXddO9D6SfMnIrvNCq8lJY8XfTYrdDYrdEpKHgeio2CdNMQ6aIh12BBrZUyxjhlinTDEOmKItdcQ67ghlqXej6O8XOPgsFhRstTVVUOso4ZYlrpq2cYDhljjattnDbEeMMSSB6UcZwp+lKaDftuznrshPWkH3kP6ReLVlp9urKTJVYtpRT4zfuST8DOj8DOjyEf6couSJ1iz8W+cM2D5GWgjlsdrqY/3bog7rESYUeI5wxalPXgP5wxX53rbhn3DeuqzH5Ce8I33kH4x8Gk3ZadeaPY/HfT3s6F8yln6FfmVvpxV8gRLXtBAPcXyW6CNWB6vpT7eewHpKeo06+ms0h68h3r63Bh3OqU9e+Lf5RET27jQQNooJ7sXM5Yz24HQLwY+9a5rB1o/af5E5FPyI58y6y7yU1LkI325VckTLNkOhHaA5UvQRiyP11If772Y7AAxWXe3Ku3Be2gHC2QH3J498e/ySGmhovWlIX5jRmkn2xnK2vAFrsx2JvSLQX8f+rCzbcRPmh6I7LYrvJYoL0q86X+7Qme7QkfDOmqIddgQa68h1kFDrOOGWAcMsY4ZYj1qiGWpE4cMsfYbYq0YYWn+fxS+QiO+orRqiGVp22cNsSx9oaU9njDEsuzHc4ZYljphKXsr2w6M22ipEycNscbVT1jydSnETJfHtIsne0t7fMQQy6qNuaB/HvpMiyes28jPH3BumYv/Tis8GM6zOzmiJ+3Ae0i/SLza8tOdZ2ty3abIVWS3Q+G1RHlR4nn2DoXODoWOhnXUEOuwIdZeQyzLNh4zxDphiLVqiGUp+7OGWJf7cTisc4ZYljpxyBDrpCGWpf9aMcSylL2lrlrKflz9l6WuWurXo4ZYlv1oqV+WNmSpX6Eh1gFDLMs2jmssZ9lGy3hiXPtxHGO5XNA/B30mxjmWMebleOKZYUOWfsKSLyv9iq55XXUUvk4b8RUlS9lbxgAy1vJ+OsGPkt81tGrmPby8huZlj9qANTRt79500K+HhvKpZOln5Ff68golT7CujH/jnjAsvwPaiOXxWurjvUoslJKCyXvCrlDag/dEvtGesNviH9Mp7dkT/y6PlhpaXxriV2aUdrKdoawN9TrTAf1Ivxj096EPO7uS+EnTA5HdVQqvJSWP9e0qhc5VCp3LWOOFtcMQi30k6h7bIdaz9udIT9qB95B+MfDqFyouuV6pyFXks9OPfJI90DsVfnYq8pG+3KXkCVb8fcWe8Q7L74Q2Ynm8lvp470003iEm28AupT14D8e71070tg37hvXUTz9kf2dF6BcDn3bT1VNNLzT7nw76+8RQPuUs/Yr8Sl9ereQJ1u74N+oplt8FbcTyeC318V6b9BQxWU+vVtqD91BP3xX/mA3S7TOLPSOu5rdZhliP7cFLf1c65az2IPSLgU/77NrDroxyFflc7UU+7eUs+oP8Sl/uVvIE65r4N9oDlr8a2ojl8Vrq471DZA+IyfawW2kP3kN72Ed+G/uG9dRLP5TLy1n1VOgXA59+squnml5o49900N8nhvx0svQr8it9eY2SJ1jXxr9RT7H8bmgjlsdrqY/3TpOeok7zu4bXKO3Be6inJ2g+ze3ZE/8uj5TqNa0vDfHnphVZ2+F3kvWAa/3gJ++gXecFfzGR//Ve8BsJ/zd4wV9aFPxnecFvJh/8vtEL/lxb8G/y07+J/J/tR/6J/t/sBb+W6OdzvODXO4J/ixf85cT/PNeP/OcF/3l+5JP0761+5JPY121e8OcS/n/MC3418T/P94Of8P9CwLdcSxH8ihf8ck3kUQ66Ka+0SehLLPUCKJ9L+StYnCe0ioTlK27V2ob887y1DPygDNKwykNiTSt5Pvr0hY52I/0ZB6/cjijxGUTrlUmUDhlhaWPQKHyFhnxda8jXg4Z8PcuIL81/j4L1bEOsSUOs3YZYzzXEun5MsW4zxLrREOv5hlg3G2JdY4j1PCOsKJ0J7fi6wZCvU4Z83WTEV3R9tSGW1dgRXd9iiHWdIdathlgzY4olz8D97k+pL/tdT5uv+l1Pm5v3u55Wb/ldT6s1/a6n1Rf8rqfNVf2up9U9r6fVF2UuIzGk0IiSthZmN++aX8oRvSDQ579Cv0i82vLTnf/eTPywfHh/1i0KryUlj/vwFoXOLQqdkpLHe8FHwVozxDpgiHXcEOuYIdYhQ6y9hliW8jppiHXEEMtSXqcMsSxlb2lDlnpv6XNWDbEOG2Hlgv53pcahjVr8NS42NK7+3hLrso8eDmvFEMtS9o8aYp02xLKUl6VftZJ9dM3z63Hw95ZtjJJlXGjZxoOGWKEh1hlDLMtYbhxjkyiN67zjUogxLcfacY2/xnHsiJJlzGRpj5ayf6bHAFE6a4QVXfNz6lGwnmWIdZMh1rVGWFF6KLTDep8RVnTNewRG4Wu/IV/XGfEVXe8wxLrBCCtKlvKy6sfo+jZDLCs/ESUrG4qun2PI177Qji9Le7TiK0qWunpjYIdlKS8rvxolS39v2Y/jOA5Z8zWu45Clj7b0X+dCOyzLePURQyzLObLlHMZybmW5PiHzIXnGXoK8XPxX23thuB8g81nnQr9IvBrzk+xPuDHol2tJkavf/Rvldo7wkZ+bFflo+yV4LJZ9vvheKZa/GdqI5fFa6uO9v4o7TtO1VtjLQ1a9jd4r/fN8b9uwb1hP/fRDpZVVT3kfjSe7ce6juVGR47D7aCxjesv1bMs1Qss1e8vxwnKdyhJrXNegL4W9L5Y2ZNmPa4ZY47rOPq7PQi1tyNKvXgqyH/c9Jto76obxR1l7h9wQP3lf9LkOWSB9iW8wHsql/BUszhNaRcIyblvF1Tbkn/sZ43CUQRrWc4fE0s4d8NGntzjajfT9nrMwV5sJ+uWUI9p+9Hsh87mpQr/ot28SnXxe0N83mh6J7G5VeC0peTfBNeYhnVsVOiUlj8e9UbDWDLEOGGIdN8Q6Zoh1yBBrryHWKUOs0BDLUvZrhliWurpqiHXYEMtSvyx9zklDrEtB9pa+0FL2R4ywomt+92BcZD+uY5ol1uVx6PI4dHkcuiz7QVjP9HEoSiuGWJayf9QQ67QhlqW8LG3IUvZHDbEs/f2aIda4+pxxHR/H1a9a9qOl7C8FP3HWCCu65v0Ho2A9yxDrJkOsa42wovRQaIf1PiOs6Jr3Q47C135Dvp5jxFd0vcMIK0qXguyvM+LLUvbR9Q1GWFGylNfVRnxZy8vKhqI0jno/rm2M0jPdF1rL/vLY8fQfO6L0sBFWdG0Zy1n6HKvxMUr8XtEofN1iyNe4xhPjOnacC+2wLOd8jxhiWT6jsFwHsFyfsNw/we/v4N6dXPxX+xaL4b6hdo7oSTvwHtIvEq/G/FRccn2eIlftWzKG/LRyhI/83KbIR/ryhUqeYJXj3/j+Dpa/DdqI5fFa6uO96+JFlxJhRonf39G+44H3RL7R+zs7J3vbhn3DeuqnH6qNrHoq9IuBV7upuPRCs39NL6Su1l887mftLw3rmCHWiiHWQUOsk4ZYa4ZYhw2xwjHl65Ah1l5DrLOGWA8YYp0zxLKU1wlDLEt7XDXEstR7S19o2Y+PGGJZ+hxLnXjUEMtS9gfGlK9ThliWOmEZm6wZYln247j6L0v9Om6IZeknZG+VxN8Yr+fiv56/t1nPET1pB95D+kXi1Zaf7txFk+ttilyH+ZZjdG31fbwoWX0zMUonDbEOGmIdNsRaGVOsY4ZYJwyxjhhi7TXEsvoOXZQOGGJZ2uOqIZalflnK67ghlqV+WdqQpV+11AlLvzqutm1pj5Y2tGaIZWmPl4J+WfocS9uWsXY2zsN4m795O2zMj/Wl3IxSLxf/9fu99Ebm8wGEflGRiY+Yv5xRriK7isJrScm7Ca4xD+lUFDolJY/HplGw1gyxDhhiHTfEOmaIdcgQa68h1ilDrNAQy1L2a4ZYlrq6aoh12BDLUr8sfc5JQ6xLQfaWvtBS9keMsKJrPh9gXGQ/rmOaJda4jkOWsrcc0yx9juX4OK66enkcemaMQ5djzItnj5fjnKd/nBOlFUMsS9k/aoh12hDLUl6WNmQp+6OGWJY+Z80Qa1x9zrj66HH1q5b9aCn7S8FPnDXCiq55D8oofD0U2vH1LEO+3mfI102GfFnK6zpDvvYb8vUcI76i6x1GWFGy1IndhnxZyt7Kti3t0dKGoutrjbCiZGWPUboU9MvK51jadnR9gxFWlCzldbURX9bysvLRURpHvR/XNkbpmT7WWsv+cmzy9B87ovSwEVZ0bRlPWPocy5ic33Meha9bDPka13hiXMeOc6EdluWawiOGWJbPYSzXmSzXvw4ZYvH5JjsgLxf/lX2YqNcRnT3x7/JIqZL5fBOhXyRebfnp7sPcHfTLdYciV5HdtQqvJSWP58bXKnSuVeiUlDx+hjkK1klDrIOGWIcNsVbGFOuYIdYJQ6wjhlh7DbFOGWJZ2pBlP64ZYh0wxFo1xLK0bUv9suRrzRDLki9LP2GpE5b9eNwQy3J85G/IckywJ/5dHinNL2mxmx3+3NyM0jaJ2YQ2zq3s4rRa5rhR6BeJV1t+unHjdcRPml6I7K5XeC0pedyH1yt0rlfolJQ8tv31Ymm6Ow58RemkEVZ0PR3YYFm3ca8h1nFDLCvZR+mIIZalvFYNsc4YYp0yxDpsiGUp+2OGWIcMsSzbeNYQ6wFDrHOGWFbyiq6fH9hgRcnShkJDLMsx7ZrABitKB8aUL8sxzdJHW+q9pbws/f24xhOW8ZdlbGI5po1rG8c1/rLUL8s2WvnVKI3rvMPS56wZYlnyZSl7S72/PH8cbqz9sfhaW7czfCba9PvMtTYv+Nf44b/ud+1vbmFa6RtD+ZQF/wYv+OVlwX+WF/xqoj83+cFP+vc5fvSnI/i3+OnfRD4/5kc/E/15vh/9mfd7NlY96d+KH/xE/tWgm4x0pyLYNR+8V9qJ7db96Gbi2+a84FfmBH/eD/+J/Be84FeTZ1oNP/iJfBb9yD/Rnx/3I/9EPj/hBX8u6d8XecEvJ/r/Yi/49aR/f9IPfiL/l/jRn8T37/HTv4nvf6kf/awK/su84Fdbgn+7H/xE/nf4wU9ihzv9yD+Rz8v96E/Svz/lBb+e8P8KL/jlhuDf5Yf/RH9e6QW/kejP3YCfs5NP4h9eFXSTCXalnPD+015kU0nGlld7wa/VBP81fvhPbOu1XvCrbcF/nR/8RP6v94OfxCb3BJpu1jpLC+XaXHO+sVRZbs4vl5fqC41ac3lhod1sL9Y7C3PldqU1X2lVK8uNRnNurtmaW6xUljuLc8uNhPc3+NGdRPZv9II/l+jmm7zg1xP+3+wFv7wo+G/xw3/Sv2/1g5/o5tv89G8ybr0d8O38fndceYcX/isJ/+/0gl9Lxq13+ZF/Mq94txf8arIm9h4/+In8m37wk7FryU//JvJp+cCvLCf63/bCf3fdquMFv57IZ9kLfjlZ07vXD/+Jft7nBz/Rz/v99G8yfr3Xj/4n/mevH/6T+OEBL/hzybzoQS/41WTd7SE/+En/7vODn8j/YT/6k8jnfX70J4kP9wfd1MWu1BrztWpjvlptd8rN9vzC8mLtfLC+NFdbbC1Vzqt3tdFeaNbK5U6t06qX2/OLc+1Oc3GutrzUXExitwN+ZJP07UEv+PVE9of84Cf8H/aCX058zyN++K9F37j/wYansOTbNDmgtQGuhXaUJuF6KewtI/lY/tZNT/2N6P1DDDpDdQK4nqb61mNGjugFRCsg+kVFNob9XGH5Cj8sH9lDIbIrKLyWKC9KZ8NuOc7LK/cmHFjnDLH2GmKdMsQ6bIh1whDrkCHWMUMsyzYeMcQaV/06YIgVGmKtGmJZ6pelvI4bYlnql6UNnTTEstQJS78q50RMB/pYuCf+XR4pLSzIWPtI0J8k7wjQ5jH6KJS/I+yW45Sn39imjef//WB7F5fLMT8YyxwBfE1OkvzuvSwn6zAb/ODXRKemgl6Zcps2pMhK8rW/QaDHh0KrGPTL3Ud8qLUN+Wd7mQJ++H1iDWtqSKxpJc9Hn0462o30Zxy8au0okEw0f5RTZCL3Nzj4wvKzCm2pKzLcCHmGMqy6ZIi2KPQ3w3W7s3To3lftuzeglCc5iNx2Urm7wq4cWAenUrAC+r2T7uUBD5NrPpnFnoXPKJUULJnnRny/JBbQbNCvi1LHrz+9uOOStGnYcQntDXlDTFlbYLkWIB/Lvyrui6hf7o6vo+UG6ZtNRCdK0jczkPdM6Rtp07B9sxnyuG+kPvYNynUz5GP5t2zs8vJ/bO/yzPQ2Bf38baLf9yj0Zoie5EdJ+ngL3Ld8rpQ1RhD6xcCnznVjhC3ED8tHdG0zyPiBfc327c2HDxx6oDNBosRuQvgSwUkZLIupBCxhea7PqvDKsL8eJxGlZvIzxBPi55V7PATMKLyJmotsToIL6sTXM4GuxlGaDvpla6gKrayqKfSLQb/cfKjmZuInTfZ+3XN5id0a8jOjyEf6couSJ1iz8W90kVh+BtqI5fFa6uO9A7E+lYJ+826FvTxopo/3RL6Rnj5IIYzmjl39tlnBLQXpQ4M23WqGvXkFpW2SN+nIm3LkbVDaJXkbod4S1SsqmBGdf7uxi5cmG9QrCYE135TmW9Ow7iQsrL+FsGYHYL2KsLD+LGGVBmDdTVhYv0RYWx1Y0bU8SptV6m8lrG0DsJ5PWFh/G2FtH4D1IsLC+tsJa8cArFcQFtbnY+evGID1ZsLC+lcQ1pUDsJYJC+tfSVhXObCidG/Yi4X1ryKsnQOw7iMsrL+TsHYNwLqfsLD+LsLaPQDr3YSF9aXujILFcYCf14WzxwFCv0i8+ooDrgn65Yry4enQtQqvJSWP/dZ6j5LU/NYoWFsNsbYZYm03xNphiHWFIdaVhlhXGWLtNMRiv+Uar6PrG+Jr13gt9VB3sVweymhjNGKkxQM4Z8P7uzO0B++xbHan0EvjD326zDdd8cds0C9T5nlmAB0Xz1JOi5nbYW8eLqlxfItLjxyH41L0FsrboLSLY2bsV46ZUW4YM/O2oD+P708T/8bjThl9JstKW8JN2/YUBNkeu/AjLpTRRVgP6OSIXhBc3PUAnk9rspj1QrueedlulmThZxmxGxNpfklbG5Hy2txHm+vjMt+9nYPnH+a87OgbmvfikytWf2SHV1Y30++ZFLb2ULlZ+i3ugflALEwzKfymld8zoDxeF5T7QaBPG3lpROs2vOdaGtnqoLNlRDpbFDpiWugOfTzh9/QFmeRpsDZVxzYJ/RlFTrmUv4LFeUKrGPT3kQ83oLXN1c8YwmdZ0tg+JNa0kuejT7c52o30Zxy8au3gp4bSxw/GR49H4cmPaMle8xV+dxnV5rPqo9C/UDtOtB0RWuijhZxSt0R5UeKvBWq7EyYVOhrWSUOs04ZYJwyxDhli7TXEsmyjZT9atvGgIZZlGx81xDpliHXcEOuwIdaqIdYxQyxLnbC0R0sbstQJS3kdMcRaMcSylP0jhliWsg8NsSzlZekLDxhiWcprXH2hpbwsfc6lEDNZ6oTluG0l++h6OrDBipKl3lvK/qghlqXeW7bR0k9YxgCW8jpriHWOsLLO66W89qaDti51qbzpMEflLN50mKN7+UB/08H11kHW/hV+WWZTSnnEm6Tye2OHGsnxn+KFt5LCUwHwX0LrbbgmKXX8riXXqjmiJ3IKiG+hXyRejXU3WW/Tto5pa7YiuysUXktK3tVwjXlI5wqFTknJ45hjFKxHDbFOGWIdN8Q6bIi1aoh1zBDLUidOGGLtNcSy1AlLeR0xxLKU1yOGWJbyOm2IZamrhwyxLoV+DA2xLOVlOQ4dMMSylNe4jkOW8rL095b6ZelzLO3RUicsYyYr2UfXvH40LnpvKfujhliWem/ZRks/Ma7x11lDLFk/0l4z4tcbtDnsDgcdrL8jA5Y2H5by2mtJrnUq7bUkWXvALfo+1qm0/tBebVrPOpXIrULleJ0KfduVKVgB/a7QvbR1qknIj9J/ip2nyNfTXjp1uzfvtcQ28p5OXCdzrY1qezrzDjpbRqSzRaHDWJNwjSdz8gkNUuYfYP3un7f3Yg7aksyvtiJPvOdyawr9HLRzksr+I/D2/8W8+d2POPzJHfzKxVHI41cujgHWnWG3HKc8/cb2RrLI7ejicjnmFeV8hPLQ/oRv7dVi1rVhXwfH+psddJ43Ip3nKXRmlHq5lL9Ch+8xHY1n11r2eukgltiy33Xx4fWf5Yz6z3t2j0Een8J2HPLw+RAnzTZEFlG9V2awDb/PoS6cDPOUhzJE2+akyVBkkVWGms9n296otONC+ZdxGyf4FTvsY36NDvu4RHnHgc5y2Jv3KNTj50QnIG+S8k5CHp+kdyrolR/mhZA3rM3ieHZsiPFMO6XKNZ5pR4QIrt9XzWq1LH4f6ReJV1t+us8YtaNBtJMfRXYlhdcS5UVpX9gtx3l55d6EA+uYIdaKIdZBQ6yThlhrhliHDbHCMeXrkCHWXkOss4ZYDxhinTPEspTXCUMsS3tcNcSy1HtLX2jZj48YYln2o6X/spTXKUOsA4ZYlvKytCHLeMJSXscNsS771YvnV61kH13zM8Zx0XtL2R81xLLUe8s2WvqJI4ZY4xqvPmiIJfGq1MM5Pj6b8Hy+QfL1yyv84CfnJ7iekyJ9ntNLvvZXsDiP90SX/LTNuSfapQe4Np7laM4dQ2JdzHNOUNZ8zonGq9aOWUOZZPmChra2NGzfuo5K9WxjyfP6WYeckP4o75VUqdydYVcO3HfbU7AC+l2le2nP62eD/j7dkMKn0OV7rCtYv+Cgkx+RTj4jnU0j0tmUkc6WEelsyUjncv/00rmY/SN+GM8ywq/G/OuiTnMSaOLeFd4zIeX/72IX80+LvW3UfMHlL9H08+PjSzR/Xezy8sOdOmYu0PWL38eTMXMKaGMZ5kHK/w3w8I87dcxCSrsmUzD/Z9C3vy3qmIGCqbVrA7WLeZgiHqT830G7/om+JLNBqR+k3It+45dkNgTpWK7n5C6sXArWIJ8qx6dmfQdTyv+Pjj7PKzzgu7zcPwXigctsIB6k/A8VHvDoyda+h4/GX5gJKKEZoHuQ39x93AV5BSctSfkIU9TaZQpYj/m8hzCjFDVZ3E+780DnYCel0dzIiRRiE4Ge/H4h249P1/Y3oF/kpNmf3IuU4Ec7u7hcTpL2tbbLcU06HS2uYayJoD9eiZJ8UsTvlz5bZeFH++SOFhtPUvkNsTCfVItdvW3UzjnQ9h4xD1jeFVPj3g6eh2u0tRhB5Otn3aUrX5lfTqa0rQT5WH7WIV9tTc8l30FrIMKPdpQ9r/0Mku+d4VN/x12+V11E+aJ98Z4+LXZyyX6DwpfmVzc46Gwakc6mjHS2jEhni0LHhZVXsDCeOh9c3H+4s//V+w4mp7sLJHZfQNfTdI/Djkn6PZXCKm+n5piMj/vm2ImP8y4q/GlJ+MDEvOSDwUlMSmR1C5hUnkxKG0Jx2BO3zNN/rIvTf1Ev3HbJKsHbLrE80pTyIdDRwvaT1G4p/0Jot4Tt2tKQ8DNN9W1dYyP5MsBK0J8kbxVoc9h5GsrfHnbLcdJCy7j4k7L4/hBLCdiPyBtioovHvk3rl5+AfuEPpyK9U0E/f6fo936FHm/hlfwoSR+vwH27Pp5bzBE9aRveQ/rFwKfOdR8zrRA/LB/NDTs+nIrdhPBvITgpg2UxvQVYwvJcn7v9bUo9TiLKSeL57XH7IndyZ3ytuS0eHtBFaW6LR0WsL+U0OhtHpLMxI52nc3tmgn79aYa9edpKG6+IRok/hnkE8vgDm0eVdmlvvDHmcQfmo468E0pe1Jbvb+7ywfagmTO/vai51ayu4U7CwvorhLU6AIs/zIn1eXg5PQDrbsLC+qcJa82BFV3zhzmx/hphnRmA9XzCwvpnCOvsACz+MCfWP0tY5wZgvYKwsP45wnpsABZ/mBPrP0ZYjw/AWiYsrP84Yb3fgRWle8NeLKz/fsL6wAAs/jAn1v8AYX1wANb9hIX1P0hYHxqAxR/mxPofIqyfcWBF1zcEvVhY/2cI68MOrCjxx+Ww/ocJ6yMD+GoTX1j/I4T1swOwXkNYWF/qzihYMtZIyPhRuG8XolUyv0kl9IvEqy0/3ZDxo0G/XFE+PD15QuG1pORx7PiEQucJhY6GdcoQa8UQa9UQ67Qh1poh1hlDrLOGWOcMsR4zxHrcEOv9hlgfMMT6oCHWhwyxfsYQi8eyUbB4LHPF9dH13vjaFddLvRXIw3L5QF+uWVFop80b8oE+H/jZDO3Beyybn02hl8ZfCGXk49mjzlOi6znCwvrDzFOi65cQ1ijzlJ8mrFHmKe8grFHmKfcT1ijzlEnCWu88JUrvDXux1jtPidI9hLXeeUp0/b6gF2u985To+jmEtd55SnS9SFjrnadE13cQ1ijzlNcT1nrnKdF1k7BGmafsIyzXPOWjA7BuIiys/1HCemIAVoOwsP4ThPVzA7BuJyys/3OE9fMDsF5HWFj/5wnrFwZgvYewsP4vENbHBmA9RFhY/2OE9YsDsJ5FWFj/Fwnr4wOwFggL63+csH5pANbLCAvr/xJh/fIArNcSFtb/ZcL6xACsdxMW1v8EYf3KAKwHCQvr/wph/eoArOsJC+v/KmH92gCsecLC+r9GWL8+AOulhIX1f52wfmMA1qsJC+v/BmH95gCsdxIW1v9NwvrkAKz3EhbW/yRhfWoA1m7CwvqfIqxPD8CqExbW/zRh/ZYDK0rvCnuxsP5vEdZvD+DrAPGF9X+bsD4zAOsWwsL6nyGszw7A+nHCwvqfJazPDcC6k7Cw/ucI6/MDsN5AWFj/84T1hQFYS4SF9b9AWL8zAOthwsL6v0NYX3RgRemdYS8W1v8iYX1pAF9vJb6w/pcI63cHYN1HWFj/dwnr9wZgPUJYWP/3COvLA7DKhIX1v0xYvz8A68WEhfV/n7C+MgDrLsLC+l8hrK8OwHoLYWH9rxLW1wZg3UtYWP9rhPUHA7AOERbW/wPC+voArAphYf2vE9YfDsD6ScLC+n9IWN8YgPVThIX1v0FY3xyA9SbCwvrfJKxvDcDqEBbW/xZh/dEArIOEhfX/iLD+eADWjxEW1v9jwvqTAVg/QVhY/08I69sDsF5OWFj/24T1nQFYbyQsrP8dwvruAKw9hIX1pe6MgpWL/8pzrn8F9+2eK9UrOaIn7cB7SL9IvNry033O9a+CfrmifPg51/cUXktK3gpcYx7S+Z5CR8NaNcQ6bYi1Zoh1xhDrrCHWOUOsxwyxHjfEer8h1gcMsT5oiPUhQ6yfMcT6sCHWRwyxPmqI9YQh1s8ZYv28IdYvGGJ9zBDrFw2xPm6I9UuGWL9siPUJQ6xfMcT6VUOsXzPE+nVDrN8wxPpNQ6xPGmJ9yhDr04ZYv2WI9duGWJ8xxPqsIdbnDLE+b4j1BUOs3zHE+qIh1pcMsX7XEOv3DLG+bIj1+4ZYXzHE+qoh1tcMsf7AEOvrhlh/aIj1DUOsbxpifcsQ648Msf7YEOtPDLG+bYj1HcJaVbBCKPOu+Nq1T07qnYY8LJeHMtreOMTQ8AVD21/33QztwXssm++m0EvjL4QyD8TXFvv+riMsrL9GWIP2/b2NsLD+GcrDery3M3TQiZJrb2fooPPdEel8V6GjvT/YDnvzcC2a3wspQB6/k4gnBZ2ivKNKu7STglYoD792tUp5+CWk05SHX0KSfsX3B+VdWJHD38T3p4l/kcee+Hd5xKR9tVJozRJPLDfut7xyj3WA66fRKY5Ip6jQYay0r1YWIB/L/3dxn2hfrdT2U+fhHr/3qcnb7zEH5Yrgr/rBT04QXlFkgW1iu+F3yLW/gsV5QqsYeLUT5+v6rn3zK8BPCNdpWCtDYvk9NqHbp2GQ3m7NT2q8au1Is02kU1RkImVXHXxheVccJDLEsdtQhlWXDLXYYz0nOYvcdlM5/vJyCPVWUrAC+r2b7uUBD5Pm2zal8Cl0B/lxrh+lmRRetb9CJxhAR+OZj1qJEp6s+y8p7/7jsSv4nk4b8rH8p7Z3MSfis1+094jSbCUH9GTsihIf1yP0sp7uKuU3xDxpJ30WlDa3HTwLJsZtyLOcHcE8bI558DxGqvGQ0NJOI+P+wbZofcJ6d1KRQ5pso4RxSi7olZWU3wb9lSVO0Y540trKcSH6/83BYDqucXKzQmfU+ECjo/HM84wooZ1fM9Otg/qgndQcJXnfno9X+hDY+fUOO+f367RjubCNwx7LxXoj5Z/tsPMctRnbqfEsmKzTktjOpfzzyM5XoL5vOxda2jjGds56N2gc0/y4RmfLiHS2KHR8j5f8leHQkE4IeXyWT5q9LpC9Sr+mnayO4zaWfw3Y64+TvbK+Y55r7AgVumwzQZBtPeWUQifNR0XJNXZI+Zc5xo4w6OcPfbNrjhtSvRXiN4C/2pyRy+cdNFjP5b7ErGmxB9LR4uVCCm5O4VG+fuJ3zt2oaUcQSpK8NYVnycM1yZ8Ou+U45ek3tinSlaldXVwux/ygnNZSMFmmUeqEvWWlzRMK7irhog9gecl5Xmz/S3FjIvt/84yOx3oSpdfGP/zOKxt17l9M3L8sH05a/wrfUf/OD9G/2IdnKA/p8Dlx2pGWkewfoJhg3GxpPfYyP6K9aPJsh715KE/BQHlOEsaHQd8fIn2XMjxeREnsR2xW5FdQ6keJYz8pvx/GntVdOn2XvQWB7hdQDjjXQXkyL1qbpewHSR/PUJ098e/ySKmeHEt7lnhG2uc80eYxOQj09VehP6PwI3wXlbzCCLzOVRYWqvP19tzy0nxjbq6TI3zhle/x2qF2RsU2pbzI+nEvsq61xdTyYRf/MZBrlAqQd47yJiFPeIxs6MyuXv4f88R/Fvkj/ZJS/s6wW26YviwpdHiuNQpWuE6sbUGvDWhj4QrU47EQ4xc8b/TzKX45i68T38Z+H9vJfvAz5OvWiPae+Hd5pFSra/Eo+7qznmhn9XVCfyZI79uikjeKr2vP1Sv15cW5pfZyrdNeWM4F/WNCXrnHvk7T261Kec++oqz5OvZnBcg7S3no64RHzdf5GRdr5SzyR/olpTz7uqx9WVLosK8bBStcJ5b4OoyDOE5dgXrtsDdvVWkP+jqel32RfBKfobYn/l0eMWlrhOxTkd8o4Rx6FeTE8mUcvIdxc0hlUB5S/msQt//+TD9uAH9bCn/aPpsctOvrM+nlVpVy0br6bHz/3s7Be+5r7u+07+m09ncO4jQAyQSBLpYwvubpVEDlosTLM4/Sb85nTBmCC8HghGJFLK3rEJuH3m/BlOcj5MIKRGtP/Lc8YtKmjjzUhnDfzqSqmacVQr8Y9Kucj20dIfHD8uHhccWPfMrRkMxL7FF6T9gvG+ZD9EVbfk3bLoDtzSntLQXprsH3YwXWT2mf5mr5iyZS9j+Aa/xzeiygff7AtWXL9dhXc+dY/u2UF0Jbcg58Xm75K/AX/0Rfi8GQStohXzYqUN6e+H55pFStRHw8AUtZ7GcnQ73dQeB+PC7lV5TyiCGPNLStRSJDTbdQl/4DPdrRHlnOOjDWa1NZ6cyOSGdWoePbdmeJTtqjur9Pscm0R3V3QD6Wb8Cjuh9Sf6b5rifbFXbzLpDNVIe1Gc1PuWwmVMqjvxIZao9YXxP25mn6zjoapXeEvTwMo6Na/Si5dNTvh2grmeMUuVcM9PFrjwk/3Tgln1GufqdGlbJLN5lmlHhrgGaXK/FvtH0sfxLayL5+Bfjg6eJkvD/BtaXAZTt4T+T75Pa/lGmR4Gl/gyCbL9V8FttWHnh8PWDdHfbyxbGJ9jcrX9o2Fs9bdepCa9XRbqYf/TsNbcgThlY+JP4Z/zSVl/qFwB2bsD7uivUx0qHtW3TMIAgybfXC6TeXZ5vC8lfFdDGO1Pp4BfCFb+21KX71ZkWRw5Nb6ai92niP/bJK/Ev5/7Kti3k98aX5Hy0WYF3WfKs2Byw56Pi1ha7fXVXklqXfb4F+54/4arqnfQ6OecDybFNR0mSfts0Dy4kfY9tM0/sQ+JG63P4XQPtli6PUR/vmdmj+gx8Vu/Q3R/94aTD6t12hrz12if7tiX+XR0zsKwtAY03hhx8PLZI9y/JwXmmrJtczCl1ckt5OdM8Q3agfP0t6LLxtCvQ5BPcJP+ZnPu+mfCn/EvDjL46vtXge/d+dW3TaxUDXwzQ7QV7RDveGvflS/naQ1xdS5h7Ij8arZqPy2cD12OiriFcpf5fDRl26pMWMvFVIs9GQcHJ0P6teSPnXgV68hvQibR78bpK1YGX1Dxyb7Il/l0dM3Jdop5q/5L58K7VL7DevtFXr0zWFLj5mYv+wRnQ1/yA00OZeCZgh8cAxCOsx25yUf6fD5vJKmzU90MZYzV65T6ZSynNbpHxLiQenU+jtiX+XR0qVvrEnLZYppPB8rxLLaOs6EsP4XdepqGuhaO+TQBfbFQTueJPlhOW1NcRSMHgckbIoc5xDyhH4k1T+UfBt7yPfloP6cu1Xh8qZv+ot9C/UOs2wfXtS4V/WxLTyml/IKfjR8yRe1y4BltDFTzuv0j1t7SZHeStAG8e1kPxZTuEb9U7mt0wzSu8IdZqIizRdryG4+NHkWArSZfBMe96mxbCj0kH7l37zfBxBnf1m1jnaGrQhS0zO6wCMz3M3jKW0eTavG0n5PwXf+wTZlauNUcK5NPOkzbd5bURirqkUnnm+LeV/UYnl/W6brvRt0cIxDvvxTNDLs5T/hGONRDvCx+XXtS1U2G7hR1u74rk0zotZpzRs3i6p4fDR3tzOtPmHYGjbBaN/e+Lf5RGT4Ml2OpwHPKbwM0nlP0d28n6SqUtm0b/HFbp4JDfPPx4nutr8Q3jD9Qnsd+4T3gvAfPI8VMr/LviLL1KshvEDjtdfS1mfxbnSOQevZxVe0WZ4riTlv+KYK6VtDxRex92ffCPjPAXXkKNUCL20R52noC+fBLppPs+1LpzV52lbUFcpLwd5WdbrV6AM+0jUHa08rwNK+f/K8awkbe3sTx3PJHjOVoA2uMZWbe0A97H82RYdV9tLEaV3h73tlfL/Ezxb+YuM61d/OSTtO1No/wrQ/muS4bjtywlHpBMqdCxjfE33riSaruf3Gs9Yn5/5+XrOfCXRWVHoeJ5LZF5nEPrFQPcve2z4SdYZXOuDKFcpf1opHzrKrynlV5TyuM6APjwgurjOsEb3NDtfIX60dRWtvdp+wALl5RQ6g/zcj4bwc9H1KyAfy98Hfu4/k5/D+mIHmmx4jWBY2WjjiEbnqhHpXKXQ8b3GcBW156SjPcP6QKx/oXzgVUQH66F+Ts1266Bta2vrUUo7quhFoJ/TMaamny69Yd3V9kustw/yGekURqRzqbbnmWwj1xvZyM1gIzeSjYTAl0vOWG49cs5K55nQnyuGdBCLj5VK05sK6Q0+S82iN8lzFdCbega90WQTOtojdC+UvrmwQgUrp/CcJXbVYl1t7VU7xkX6xe9r7Nn3jQv9IvFqy093nqCt4ZxWZLc56K5NNTsHKtXGHZ3W/qMPH+TOEMBS0CvkNQJko5DfXC9iKm1ww7JRwnMHUZFKVJ8nItrEfhBPg8oOyteM8HRKO4MgmxFi/TQjTDv3bQ3ysfxdsSPKeu4bKg+/KKc5HHYIXC6vtKGYUg8fRGAetvkuR5ul/GsdbV4J3G2+M+xtcwg8rVC9FcgLU9os9zcG+kMBwdBkvDPo5X1YfcL6F2pw30l0sB4Ouu+gQVfkkLZZqAb5WP5/3drFfDcNuniOoiuI4vMah5WzRse3nNPOkkX51aBMSOVFfgUFM0r8YruU3xvL2PPCnHpGg9Bi3cL2RXrw4Oxg2bh0S8r/J9Cth8dIt1xY2lnMLt/3tA7MKp1yFltC+k/7wOzvcr1CzhqYcT1XYMZlQyonijRqYKbxlFZ22MAMlYADM+0Jo6bYWmCGT3PRgGwVqdr3JiY+RURjYhmfgjZoAUchRRa5FHx2YFK/kCI73uUk5c9BUPal+Cm11le7UvgLgmx9tYvaEyXfb3LuIjo+Vr+jxG+1DtKNO4ivnIL15K6zIQdMnIxg+cdhwPwFGjC1VdX1rjyzLgZBticWWZ7WD9JrllFBwYwSB1BS/ssUQIVQ385/zLcv3lPV+XYWXUf62o4g4buo5BVG4LVWrs3Vm/PlpVp7bn650/cmjPDK97I8cX22Ut7vytR8U9txdBrkGqUC5K1S3iTk4ZNbPnjPT8A038wif6RfUsqnvT2tYUVpwgOWHJa3AjyHQS8WP1WOEvqVPORj+a86FjQsPvzCkwf2ZeyrorQn/juoh5cHJKEnctug8BKSXKTst0AuX97V25ZQaYtc5x00AuVeLkiXHdPIK3ivDnvzVjLwhrRXACuv1AsJQ/soGsfPGibeYxspKfz4fIKDNAfFL/9uyCc494fdfCy/H+KX/5riF2wP8oj2lgv02IF9itSfCvSFTfYDUv6vQN/5Qz55ajO2k3lETJ6/SEpbAPqbMVgAcp0AxfIIgmzzhhy1Q8MqBN0d4+gfXx72lhdZpfl57gstlkB9ZR+ujYuMlbZozrG7lPl4bGyRTv73ZE+D2v9ToY45C5g/GBLzFSmYAWD+vcNGrw166bEf4nusD1w/Sn5Pp+p+yPWIH/waj2MoC2yT0B911yrSuphvaLr6WfN/LqzCkFie35Stufyd1g+u0yG0doRBr0w0OtcqMpHyRx18YXmxYdR9qSsyPEY874l/l0dLVVd/44ethf56PuQqv19E5cQ3TwT9sj+SghXQ7xfRvXygf8g18pmTcYyjjaE7UngWHgaNoTuIhyj59ZmNsvZGsSTtjWLkkVOefiPfUX9/h05mDRQsLT7nDz1qPrcwAIPll8Xuo4QPGqTtBw7u29957f77DzcPdu483HnooKK/G4Le9k3Q77RTuJmvGSrHD0SP0O8TCn1OLANMM0o5ToPs4Da4Xo8d3KbQ1+jcPCKdmxU6LqzbFCyXn75ZKX+p+OmbqJzE76P46ZvoXpqfZl4wlr8z7JZJi+UrcYzsN/ZoLM0Eug0j7aOeaOeIXhDo8afQn1H4Eb6LSt4oa8zVWmdpaXF+qd6abzcr9arLxvAe2+QxpfwLlfIi6+OBF1k3tDXmYyDXKBUg7yjlTUKe8KitMfvxG41GFvkj/ZJSntdwsvalhnXnOrFkjRl9L64pY6xTi30ArhnzSUtzShmXj80pbXA9w/PsA4b+sGOO8vDtZd64dVZpa06ho8WM0t5IrrkdXVwux7yin16jPOxz4Xvc5MsbgnATzB1htxynQTL8QYa4W9sUtgb4LCdtzD1Gv+9R+JG6x4Ne/tlmeM0O6x8nrBMDsNjWsP4Jwjo5AOtVhIX1eV0yHIB1N2G53khYcWBF14eDXiysv0JYpwdgPZ+wsP5pwlobgPUiwsL67FvODMB6BWFh/bQTN9Kw3kxYrtNOzg3AWiYs7YNngvWYAytK94a9WNqHIjUeMIbMElf6+ZBd9jc9hH6ReLXlp7uuqckd5cO+93GF15KSx3OWxxU6jyt0NKxVQ6xThlhHDbGOG2KdMMQ6aYgVGmKtGGKdNsRaM8Q6Y4h11hDrnCFWwRBL1g61ucMRojPsmhj74UFYmg/dHP+L0pNrpbc3Hz5w6IFOQAnxckH/GumxFPolpX5AdXN0r5SCJThch+er0n9TSnnE471HH4E5Ip8gzPX3xL/LI6WFhjb+S9LWcXjswzj+jrA3j9dI5JqTNieRcpEsfrSzi8vlJGnrzGhHNxL2sM8bsb5r3+zNI9K5WaHjwrpRwZLyWrztWmcOob7U9XsyXHedWZuXaTH7etaZRW67qRyvM2OMEKZgBfR7N91LW2fm9aBvXJB144Vk3fgE8Ym0Q0+0c0SP5RkQfe2UZOG7qOSNsm5cb7Vac5VqdWm50qqW55xfMcV7WWzsuUp5v3a0oK4b47pWlAqQF1LeJOQJj9q68Zon/rPIH+lrXyLjcdiFFaUJD1iyboy+JG3d+FvKmrA2pjwv6OVl2DHleQovvk+Peh7RwTEe95N+r9Stg3JLO/XwvrCbj+XfDvtJ/02M6VovzwW6343+anu6mb+0/aT8nFDK/xn0Ne8n5TZjOzWehQbeR//O+0ml/F/SmBMGvW3fE/8uj5i0/aRCS1sL5TFWiwXwnuv9MCnnt43Dr9fzs1EcB45RHs5Lj1Meri8uh715uE7nWqNapTw8jfkU5X0g6JUf5n0Q8lAXOWnxfRhfR/ZwbIjnNqg3/NxGOwFaeyZwK1xjnvDK91jfsP7RlHrsR/w+N+7uZw394Cd7H7V3YLBNQl+bHw4zviCtImFZy87VNuSf9QDXTXmtUsM6NSTWtJLno0+PO9qt+QSNV60dvBas2dmtikykfOjgC8trB0VIXc9fVq26ZBgCTaG/nvmryO0WKsf7WVEHT6VgBfT7FrqXNn/V/Ggan0J3kB/F+jw+In2MF3NbdZpZ35+W8vMQLxbgmteQEEv2SXqes5uuyd0edstx0sZlaVOko98fYi+A1pc5wkzro7T10K1bu7z8cKeOmQv0eQLH7SLLrO+BSfkrgAeO26VMIaVdhRTMW0Hfdm7VMQMFU2vXUWoX83CEeJDy10C7ZK1Zi2FYB/le9Hs/XLvioZyCdSwDVi7QfQ/rXY6uxR9mXYeX8s929HlO4cG1dy1PPHCZo8SDlHmuwkM0dmyK81v7Hj6a8qiEp/T8qIS7j7sgp+CkJWE5ap6otcsUuB7+3q/wgGf2tDsPdA6mPR/iRk6kEJsI9PR0es4iPl17zjLsPEzKDfOc5QfxQHihYgLGmgh03yj7rfzOtVrJORba2S3a3jM+l+Qnwbb561haHKmtfTAPWB7bLfxIX2lxvYu25tv8zjW78l2J8SYD91yT11Vf7pBvGPS30SXfFaV8CGWEH20OskJYg+R7Z/jU33GX76svonzRvlYoL+15c5rsjyt8aX7oeAasvIKF4/X5wev+w539r953sIMui5sb0PU03eNhbZV+H0thdTOV4xiBj9g4Sr85ZnhU4U9Lwgcm5iUfDE587uxbQAXzpIKDXoMVN6ZtY8ZwOkdTQe2RjkvttemI3yN+ym3hZw3kppnVacjH8k2HaZ9W2ohyzfJoFNsdxtfa1mHefuDnsWO5JbyeUeSVV/iZpPL3KfLSHsXiY4koFUIv7WlrH6bDfpsEuoP6KErcp9q2a+6bKJWoPPav9rhQaGrLCWF8jY8LteM5VojXQfrKNulpi0tH6K7344dHHDbp68OC2rZ5/mDpWT/ySnzYOUVeOYWfSSp/KqNNrkJ7olQIvbSno9kk9hvbpKuPosR9qr1ywFtbo1Si8ti/2pFQQlMbJ0VP8Ego7XiAXMpf4ZXvubZktMJeOiuGdBBLHp9Lm1ehjqaHd8TXnu2izDaPy45nFX54rPoYLTXiKyL5oN+f3hH0lj+n0OWPFiPdc0QXP+TLj5KihMv8HydetfH5VIY2/yEstX6C4jltqsZT9V8D3r+6K71+GPTmhZCXpzy0MY4jV5V2om7yB0el/KeBz6/Tlq2LMa5pfoTHtc9m9NPxpW8/vaz5aZxfsZ/Wxl4sP+zYKzLTPuqb9g0CxEI9Sdu+lvbhXlzKwvJfUR4TaFPkVeK9MCTvOYV3bdw5Be3go5Q1+a46+DgHWFr5tPjijxSZMCbagvbRecb8NmD+M2399/L6XaW9LDw/PoDnx4hnKf89R1yqvULnmldor7hoH6fXXnV8nPKQ9xBwEXNCKfsqoq+9mhkodAMHvxzHDOJ3Jb5mX/kfYRz7i629ZcSH/CX0xzdpDPDzCmd3C4lmey9IkU2afmj+TnvllrGkXiHot0PX+IMy/ZutOubkkJh/q8QLWozZDru0/2NKrBMljnWixP7xlMIXxlCu76h4PVoUfAyuN2kxNMY9WP4HGWOEU9CeKBVCH+3plLUYAfuVYwSMB7Rxmv2gtmaxSmWipH0uY4bytG9fWY/BD9KxoEiHX5NdddCM/rbja7/fsVnum0ehTqKs09b8/k/HuKetp7m+EzRoPU340Y5EOHNB5NW1YU1euQzy+n8z2vAKtCdKhdBHe3QbdsX5Wp+64vxBfco2rK2/aTbMfmBFoZPVhqUufh9OW1Pl722dVjBccjpNZfAaxyqtfJo+bYnfL9Bek/Wz9lIpcwww7JrkNuCZfYYWO4Vwb73rfVrsJHWn6bcveT2myGtN4WeSyu9S5HXx1nArFc1nYL+xz3D1UZS4T7V42LVOizHwGcpDn8HzkBXIY9t0jc9RcvkTqYsfeXZ9kHlYH+b1uSnEBNpzU01m/Nz0Nod9azGdKyYY5EeFH81fX5jnphVnDJVT+GEfXs1o3yG0J0qF0Et7Khf7uakrJuC1Ne07yIPG+OsdNilrdV7ngvCZvfXOBV/qsDHNd+Xh3nrnWa5jzfzu5ag4fVJO4Yd90iueBjbmirtdfRSlYf0m2xja3wqVCxWsHNyTcUlb7+Y5G2IPMyeOknyn3a8/r448J36zwza1fnHZ5tjPiQ3Gv3dltM0VaE+UCqGX9lSe7nNibfwL4+to/JtyjH9Sx+/4V264xr+80iYe/x4ccvwL4d6w45/rmfXpFDpYLkqaPKO0J/5bHjG59oF43mc5lyN6Ig+8h/SLihwN+am4+hXlM0Hy8bSvsh4t+Wl7eN4T9ssmzb/zWCz7b6J0d9jLd5S0I01wT8mj23pxtb0WWFdo8F6L1W1dzFOEifW1sY7n0KgzUjfC/dGWp65da3KuPg8VXPbdUynl0+LJc451N097TOrCs7bHBNuV9jzuAw6fqY1Jmq0wD1ge2y38XLy9k1XnOuVphR9ep/zoWK27VSsXe+8kxx6uNTnt+BHX+Iy+gv2CNp/QfFgB2qX5G9ex4Tm6XiEeoyT7zRDX89jaYD+VZvNpfupTQ67FXQH3hp1Tss1rcyUXbU0HXH46S/s/f+H9dMPlp7X5GfvpLw3pp119ZrHHPWuf3RnqvGbtMyn/tQv+TKvbZ+sdK74x5DMtV59l9cOuZ1pZ+0xeE2Zes/aZlP/O07DP/vVF7DOU6Tmqh7zzPJTH0GJKve0OzLUUTNc6BmOk6YprfUzK/4WiK652rWVs1xmjdp0Zsl1S/vue2lVIaVdhyHatDWhXgdol5f/WYdt+4p7KyM8g/y5j7I57/6JUCL2056Kv94vMtPX+AuXlII/XH6zm9H9Jc3qel0fJ73FlXR3T1j7yiux47eN/yahj+EwxSoXQS3tUHcP3H1nHViAvr5RnHXPt30SZlZTysvak6RjPw6x07M+29JZDm8ql/A0IT9IEte200ja2RZyHoqxlHjoO78ghPzyeTdIYpr0jt6bgSPlB78ixXZ0juto7cqifuJ65gXjVnkWdzNDm3du7mEU6hhr1VHREmzeJbvidZ3b913rfOSuBnMd1jEQ7Y/+lzYWx/LBzYR4jtXeVckG/Lmk2zs/E0acIj/zMBnEj/btmy2D+15S6bH9TKeXT5kXXg14M+07X61Mwnw12deP23vZjH8wAz8+/EO9+nV9Xlbat992v5yp2xD4zCPT5t493vzS5oi48n/yaNk/l/sZ5C5bneQvmpc3HNLs9p7SRZTiVUp79m5SvK3qsvSvC69Maf9ox+DwmYV0ck1zrzX5j3OrIMe6LHbotdVBOLt3OGj9q+xJWSV6e9uX1PTsedl/CHWM1plarF/sdLZ4ToN2FhKWNqVrcr80hhEdtToBj6t/HnTFJ9V4H/fbPY7DGocULvMbxRodtav3imtsNWj9g20S7XXPUQ92ZVmjtif+Wy8sjJaEn/neDwkvaut07QY5fdnzip5ff0ZJrTup33vDUmID0gqB/zov0i4FPO+ju18kaz3t+v2kZ9+ug/uJ+HewbbZ6grfHhfPVeiqtx/NX86CLkY/kHIa5+bwpmEAy/jiJ1I9yF2Gd63kfqfLcyy/r7+xz+0OXfojTqvlv0h2coj+eOmId6FFI5bV6P5VuQj+WPghz4/Bsv77jBO0OPDeA57R23ExnjJnynJ0qF0Et7Lvo7biIz7R23FcLS7Bz1N8teCm0dhOONxxzzKRw3XOd9ZOF9VeGd/Sn7qHtprhVCuVMZaGp+0XP8V+H+GPYZ1xMXMP4Tfsb1Pbu8wg+PD7+U0ceE0J4oFUIv7bno79nx3Ax9wCrloQ3x+mVa3HBNLFztzJUcXYcKr9qai9/5f6XK9oM6Firy4fn/5xw2qc2t0e8MO7cO4+uL+F6e04dp72ayD/u9jDZ5Qc60Od//F/s5vcjM9V6e6zm9tiYZxteRTf5LfOC4TzkuNMrJHFP6UPSCUwHysfy3Y70oQjvkb2EEPpcXmpXlWnO5Oddst+utJn+eM0rSZ9Fx9U+eH0brQejvDOfBZcGf9IOfnE+Ga7Ta+Cn0RZcmoHwu5W8Q6GsIQqtIWMZtq7jahvzzc3zeWyXXaViFIbH8fh6t26d5R7uZflp5zQbk/pQDH8vLWIQ6PEWy2OBHFlVXv00BTaG/ns8Pyu9rqJys7UwE/fKeTMEK6Pc1dC8f6J8fZL+kvesldTz7lGpWPyD0i4FXe0j8wCTxk2a7+FmSB/Y12/EXtdjlcdehOBGOm81dlwyLdI/VYYLqSfirDaHMZ07B0EQgmNrXHSeoHrttjW4QdNWV3ccgLLnOO3hJw8gRxowD47LpXDYdJV02nWymYx2Nt5bml+qdpdZ8pT5fq5fbg6Jxa/r1ueZCq7lQqSzWK516Ze5C0+8s1RcXlhZbc+V2ebGyWLvQ9BeajfPUF+vN+ny5VV6YH2Y25HIXqOf3hr3lJRKbCtyzj0kuv+Opv9qutCmoI1j3h/2YzDO6Uoxwm2EvD4kLBh7+mFYJUA48hGD0aeiyW1mHEKFfDLwOaRXuD+GH5cNPcj3NCJZyhI/8bFDkI325UckTLFk5wZUuLL8B2ojl8Vrq472dsW6VCDNK8rWXnJKXV+6JfCPet+3obRv2TS7lr+DyPZ7xomx41QDHS3zyfe2O3ragvWtjrfgPtsUX7uhi3hBfa+Mx95/2NlXauIr00vzVRKDzdzP4Cv5w8gS1GdvJPCK9gkI3SuyvpPytMQ+eQ9kyjxtIazZwxx2D4pQg6Nc7LT6ZUeiIvDYF7pUJl59wrRCJzaW9LSt4k1S+roxl0kfTRG9P/Ls8Wkq+JFYEnjRfOE08S/kG8MxPNqYVuWl+g3nA8tOK3GaDfv8qdT3La8klr0IGeb1EkZf2ZGMS2hOlQuilPS3tyQbq+yTQTetTLD9sn/JbhhjLbqQ8bbWO/THS0eZm2ukh6Muvhf75Ju0eQPrcTs1HTCntdPkIrX3sI147ZLx7X9iPyTxkjXel/BuAh+844l0c39+0w80r+2B+61jKvxPG97fS+K6tpGpjQ57ysC9FRjg2TCm4mg9indBsBcvz/EN0fyqlfJpPaTnGjU3U7j3x7/JoKfGDm4EnrR83Ec9S/l7HuCF1UG44d2Q5b1bKY7s55kAfI3Wn6be1nxVeZxR5TSv8TFL5hzKOG/hUJUqF0Et71K/oYr/xuOHqoyhxn84o5bFvpH0lKo/9q9n+JspDuhuJh0HzVR5TtBgSfZ+2xIwyED796mKrkiN60j68h/SLgVdfUhlWR0Q+M37kU3bp4IwiH+Fnixd+yjXRlZJCW3iNPyDT41ew/AzIEMvjtdTHex+mdYJZqCf4JcqLEq9NYF5euTdxkbBKChbKTfo0suM1kgXqay7lr+DyPeYR+1N0XujMGNJBLInPZFzcovCQozyhw/eYDtaXcpqdRP/2xL/LI6ValXVUaCBt7Fs7G51byOpThX4x6LcnHz5V02/NVkR2WxVeS0G/n3go7JbjvLxyb8KBtTqmWIcNsR41xDpliGUpr2OGWCcMsY4YYu01xLJs40lDLEu+DhpiWdqjZT8eMsSytKEVQyzLfrTU1TVDLEv9Cg2xzhhiWer9uPocyzaeNcR6wBDrnCGWpbwsYxNL/RrXuNBS78c1ljtgiHXcEOtSiOXGVe8tY5PLY9pwWOMay42rL7SM5Sx9oWU/WsprXOOvBw2xxjX+esQQy9K2LW3IUl6W45ClDY2r7C39l+W63LiuDVnql2XsO64x5jiOHdE1P7OyGDvyCvYElJtW+LB8riz42z3hi6y2OWSF9Pk5t+RrfwWL84RWkbCM21ZxtQ35Zz3APdEogzSsbUNiTSt5Pvp0q6PdSH/GwavWji2GMpk0xOI9gNreIO256rB6Is/iUTekrmd7Td6U3+KQE9Jfz5vyIrc3UTn54tRE0K8HW1OwAvr9JrqXBzxM2r7OLHu/8B7rivZukEZn04h0NmWk83Ruj+udJL/7WquLWccZoV9UZOJjnNmUUa4iO20vTynot+/3hd1yabbv2ueDeUcNsY4ZYq0YYu01xDpoiHXSEOuEIdaqIVZoiHXAEMuyHy3lZamrhwyxLHX1sCHWuPoJS3u0lP246uppQyxLnbDUVUt5nTLEsvTRljHAmiGW5dhhaUPjql+Xgv/yMQ5leUcI43y7eUdtKUf0pB14D+lfqHeENLlq7whp76tI3RLlRenhsFuO81zrOxrWAUOsY4ZYxw2xDhtiHTLE2muItWqIddIQy7KNBw2xLNv4qCHWKUOs04ZYlvplaY+W+mXpCy35OmGIZan3l4JOHDXEstSvFUMsyzZayv4RQyxLvQ8NsS77iWeGn7Bs4xlDLMt4Ylxlf9YQ67INDYe13xDrsg1dPNlbzt0t58iy/4zXkKK0J/5bHi1VpxW668Su8Q0+y8GQ7+SsFTy3Ds8xe9mVvf2A55TlqW4O+mGSyv/mlV3MO+NrPmc7gOtpwssFpvseMn/9VegXiVdbfrrrfRPED8uH1/vyCq8lyovSvrBbjvPyyj0X1jFDrBVDrIOGWCcNsdYMsQ4bYoVjytchQ6y9hlgHxpSvVUMsS7235MtS9scNsSz70VL2jxhiWbbxrCHWA4ZY5wyxLOV1whBrXG3bcuyQeGI26I2Joms5c2426I+dZoiedt55lDx/y6Ii+Bv94CfvMww6v1nou77rwX8Fi/OE1oX67obWNu27GyUqzzJIw9owJJbn73skfeo6vxXpzzh41drBZ3lrXxbMKTKR+xsdfGH5WYW21PV8zn3VJUPtTOr1vAsicrueysm5uhNBvw5uSMEK6Pf1dC8PeJhc37bSvh0hdPF8cOwDfu9COwMc77G9aLLV6LDv3qrUy1Ee8uB6VxHrX5j3yurJmbvyblHaeso2yMfyvxOvoWjniWvvXrnsc7tSHtst/Giy3055WI91Y9j30bD+Nged6RHpTCt08koerpHNKLgiY8/vrdVzRE/4xXtIvxj41OXuuOvSoyixn9mh8FpS8nDPH+YhnR0KHQ0rb4jl8lfbiM6wflHT7xml3rjrnKfx2qlzmlyH0bko8bnZ69UTX1izQX9/sx/UZLPdQQfr8zvqWI91ju1rT/y7PFqay6pzQr8YeLWBiqv/NLmK7K5QeC1RXpRYT65Q6Fyh0Hm6YEXX8nxM9Ffzp+u1E6wv5WaUermUv0KH7613DNhO7Rl2DNBs2zUGrLc9w9r9eukgljxjZBuxoINYTaKT9j3G/0zPOeOfqd9jlPf3J6n8b+3sYv5f8U0tZkWbwPo4196mtIPp/T/xhfjiq6C+oe9Tv20otPzOlSrzM9RmTDNKu9n2d0Ie29EuyGPdvxrysL845ek3yiKaw3yPvl8UKFiajuygvCuVdkjeVUo7NH+1jfLQ9q+kPPQ/V1Ee2lg77JZjvc0H/X3H3w13xc3yG21PbAFpT1L5G2OG/cbF1aZrfBHaV3iincU/In1XPFJU8kb6pnej1VlcqtfnF+pzc7XWwrCxA/tFLK+dA+HX/1Ub2rfHrgS5RqkAeVdQ3iTkCY+Rbzizq5f/Kz3xn0X+mg/A8kvQhmH6clvQ74c4NlqvnTcuiJ3X2hfPzmvtcbbzamepNd9sLtday+VWc7ljaeeub6H5sfNa8+lt57WmhZ3fBW0Ypi+1+R5/g9XCZ1xee02S17XXKC2H3XKcN+x6KZ9P52sdjGPIYdfBtLPfLuI6WGadu7wOdmGwtLUrjmeG1W2sn2Xtym/MkX3tVegXA682UHH1nyZXXjPAuiXKixLriRaPXKnQebpgRde89oq6w/o7rJ1g/bQ4VPK1v0KH77liC372rNnQescAV9zhY000q92vlw5i8drrlYZ0ECvr2uuhq7q40T+Jm7OuvUr5Jqy9HolvautqaBNYP+vaq5Q/QXNPXGf0vfYqtDyvvS7w+iombX2VbT/r+irr/m7Iw/7i5Gvt9QrK09ZXJW+n0g7NX/Haq2t9Ff3PTspDG2uH3XJpfg77jtdeL8e6bgPIBf3+0yrWzQXdd/rWO+4i1rQhlmu/VdraHdJx7bfS5mpZ5vTjpnO+5/Q7Msr1Uphf8Zx+2PmV9lzt8vyqX+cuz6/WhxVdu+ZXrL/D2okWm/ieX7nGAJ5fDTsGaLbtGgPW255h7X69dMZ5fvVnRvOra2B+9Rc0v8K5E8+vZLzHMtpzPt7j/tc0v7qYe1sKXmjbzq/YjnzNr0QWw86vCko7XOv32tzLFUsXKE+LWTX/w3Mv1/xK83M4D+D5VdqaAv6eVMpupTwp+w8xs5EN7tqZTsv1vsxMoLcJ/QG+L/POUOflH2NeIj34eso7KBMpmOJj/Mb2rTKPt9hGbWyYpPL/O7QxIF3HZ8Qie5mDFUIv7alEfDwBfLD+TQJdHpdc81aWE5Z37R9zzT+19wTRBsRW/K5hdXUA+5jHPc0epfy/ZNQBkevF0AHcD8w6oPksbd+xS2ewb9jPut510GijXrAO+FnHceuANk6wDmyKfe0gHRC5XgwdQLmyDmjrglg+iw5oY3QWHdD2veNYwPtNBHtKKY94PB5dCX30T9t7+dsM9Vl/ZxRsHF9d/qyotIPP1MK6eKYWx9fXQXz9rvja87OF5N1xiSPTfOPOoJdnKX+jYhc5qoPyco09u5TyOxUZanHhLsrT1uRnqSzGesKDxMwFBTtKPFeR8rdRf2F87XuuspvasAvawHKMEs/vpPzLQf9eQLGlNgfR5MmxuzYHmVX4ln4Q+V0beJFfou/XBV0Z5BVerw16ZSTl5zOOA/h8LkqF0Et76to4cE3QTTwOXAt5eaU82+R1SnnsG5FZicqzfeJvxLoa7vE4IDKcCvQ+wnUMLP9SxziA8eo1xDva1i7KyzJfRJ2+cD68sshrAZhc77JoawG8hnAN5PEaAurBsGsIIoth1xAs/BDv5x0Xu5V+iBLbLdpoXinPdjvIzmV9sBT092Xauz5IcxibidJdRA/1RfoGbcblM7T5A8fAWBfXQDnmasGY98mnScx175Axl7YOzzxg+adLzPXwMyDm+gDo34F1xly8H+WZFnMdvxxzjX3MdXadMReuKVjEXJ98GsZcvO/q6RpzufzQ5ZjLLubKYjNRyhpzfdJTzHWIYi6h/xkY8/6e7NXTM95kDMKYKu/gn/3bFxwxlyYvV8ylxWjYbo65sN92Ul7Wfal83gTGK4wdJY65pPxXqb/Qxn3HXFdTG3ZCG1iOUeKYS8r/e9C/r1PMpT1r1uTJ5y9k9YPSDyK/a/zIr8Y+CfUdeb0m6JWRlP92xpgL90lEqRB6ac9F9d2an00bh/E3YmGcwDEX+kytj/AsGiz/7xwxF8ZOPH7gc1reW75doauNSTh+XBgfXmnwfhhM2n4Yjp3QDvkcmKzx2LDnwOA74MPEXBZ+iN9NHxe7xfkH2y3aqDZfYbsdZOccc2Ffsn6jzfAcK4vNRIljLtQX6Ru0GZfPyBpzXQm4co4VPnsMoM6e+Hd5yFRttzuVemVhsdGp19uLczw+R0n6ZpMP+o3G/GJ1qVxfaLeW2/XaIPqR3n1zuy5P0XFJM8o9wRWf5unM8mqO6AWBvg9c6BeJV2N+kn3gk8QPy4f3gU8pvJaUPI5ttT7JBf3679qzUFLqZzmzXGvP5qC7V+DAwX37O7c3Hz5w6IFOQIl1JUe/J1Lo55T6gQML6/iwq05jsV1eXO40K5VKtV3uXGi7nmsvNcoL1eZiuzXfrs21hrFrbd9LLuVvlPIO7JKC1Qmf+uv5mw9V7fsAgR1+ReSkfcPB7/cmlpez+jehf6G+EZH1mwR+vzuw3In2NYnuoc/QvsXBfGwgHoueeNTiR/w+SJQKkCd8RGU2Xt3L44QnHv3a6HJbixHwHYvdtCYkfYPzbtT7CcjH8jfs6mJeF1/PBr3jAvop/C6D9s0O+S39NaGU5TOa+DslmlyxPO6Z09o6RW2V8s+J2xfx9o80h/Sly8LzJuApr7S7SDxL+VuBZ14HxL2ALp/CPGB5bLfwo52TuYnqIe+435Lvaf2fo7I8xss4iPXSfqd9L0HjYaOCw+MwYzJNLZbjuVJeoYM2izGF3/d9ynPaWCxJi6VzlIdtf13YLcdJW4vA93amMqxFaPKbojyL2EvuT8J9psvx9hSV5bPFkMf1frsKeSwpdKYId4OD/xzhFJR6M4Fuj9rfrPzmFH5d89310kGs14e9dLCfccx8LflPHCfySt33ht18LP9GGDPvyThmsi/BNtwTdu+xz+Y4mW2S13Z5bOQyGCdg+bcpYyP7B8SK7r0jQwyixZUcgzwK8nw3yVOLMWaDftmwDvOefYy/ZXxhGdwLfLR3pdMSuc442hjdu3+XXg55wHKMoY2d/N20glJvVuGLbY99x5SDhjaeaTQmKW/U/tHGbe3djuKAfO37YYFyb0IpPyj+KKZga7jad9Y0P7+R8nJKHvswbC/6MI5NtDkf+kbN7tL6zhXba7xniaumHLxr8kM/ZL1WVG6UK+XWwtzycqU931yqD1orkvsbwt52PfkX7k1Cu6K0EctT3jTkFcJe+sX4tzyPZizhY5LKfxj6OkpTUEfqlxT6U0S/h2/lHuoaY+WVe1I+6tPHYh69rO3PLTaai0vlSnW5Wq015gf1qyYnXJuIksga+2JKadsklf8YjDkfpxh5UqEXlfuMo1wu5e+TGMq9Qth7T+sj1F0pL7SLYT+PkrcJ8iaJzub4N8oLsYSPSSr/adJd1DepX1LobyT6PXwr91h3NynlNynlo/75VfJH2HbrtcUnaRI+3mPePuPRrubr85VGo9lozbeWF+utpQu9tt9anF9erNWWKrXFdmexMn+h6XfqtaXlyvLiwlJtuVxrVC74s41mudqpV5aW5iqd5uLi8gVv//lnOsvz9aXGfKt6fgmzdaHp15cXmvPLC+W5arveqbabF1z/5uaXWvXzvdCpRD+rF5p+c6GzWJ+vVVu15cVmo9y40PSX2vOt8mKt0m42F8oL8431PFvDtROcu/+bDHN3rMt78aT8fwvj7b+lmFdb09HmOROUp83ptTmQzNW0MxSS8Tfon1dYrgdmiQuQ/oX6rqa2lu367s4mP/zUhZ/NCj/aGRbR87QtQX+fIX+ChWuXd4dP/dX0i+dJUxllo+0d4rk89jHvm5hQeHCtAbjWIDYF7nUIngNqdsx102SBdi9zRl5j+h/A7qfiZ4Suua5mv2z3bBOYp53FILq7mertiX+XR0uJ7ibzgkCX6eagV0ZS/oeOZ02aPeB6B69bzijlsd28VoT2ksx96bexvJI9y1sGyGuG5CXl/zeHvLT2b3DIa4tSfsYhL5Ql1mXaab7oQuniINmyLkr5/6LI1rUvwPO+0jltXyk+T50Eumn2on1fytX/mr2UqDz2t+bj2Vcj3U2Uh76Z/T/6ePFt6Es5fkNfjfFb8nwi7Jbzsb9R+iMP7SrE95C+tgYn5ZKzlfzwWhZeZd1BbARpYlsmqDxf8zrf1Vd3+cY2Yl+71uu0NQ9cCxIetfWxTeFwWBsJa8MIWMKXtg60YZ18aVi8HjrM+ubmuG8iG/z/Afg6Jd4MOwQA",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "check_timestamp",
       "is_unconstrained": false,
@@ -1838,7 +1595,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZfRjtowEEX/xc958Ixnxja/Uq1WAbKrSFFAASpViH+vTTFeFgeEUNtdKS8o41zbl3Od2NmrZTPfvb+2/dtqo2Y/9qpbLeptu+pDtVfAx7bNuu5judnWw1bNkJyvVNMvwyUzHSr11naNmgHCobpWI+mkRsGz2mNBbLTnk9iAuNtiYM90UofrD3K0ruQEUJITIM5qz6XRjZg0OIG+UL9UCmRCM4bGTmjG0LgyGjQZDd9BQyAJJKHOavkzg//bM6AuzWBNystBjivmfM1ILNsESazLlLgUQCCKKV0LcDddsDldo++kC8IuW7HPpYswkRkhgxOZETJmIjNChr42mf+3iyBPZEbIyPNkvD6TccbeIWPTeieTuQDJ0Yx92oyjHJPzdNsMeG/Oj5/3fLFxl8Bbn8k7vNrn3fe27/+tfdRazkdWjWBu2w//L40N6D4sHTq8hGo+tF3Xvr9efI7p+EPFh58NnIZjK58XIsnjXezjXdzjXfyDXUIFxw/TYkey6TUlSJ+QhvJnPbT1vGsiy3h31y8S2lBuf63TnQR/PawWzXI3NDGGnEDcscMLkTAet+NhmKFiyd5iE0KFoekQZv4N",
+      "debug_symbols": "7ZfdbuIwEIXfxde58IxnxjavsqqqAGkVKQoowEorxLuvzWIMrVOE0PZHyg3KOMf24TtO7OzVspnvXp/b/mW1UbNfe9WtFvW2XfWh2ivgY9tmXfex3GzrYatmyGQr1fTLcCmAh0q9tF2jZoBwqN6rkXRSo2S1x4LYaM8nsQFxH4uBPdNJHa4v5Gh9yQmgJCdAnNVeSqMbMWlwAn2lfqoUyIRmDI2d0IyhcUU05CCjMTfQEIg/qQl1NiR8nMH/7xlQl2awJuXlLsJlKjESy2kphGuXKbErpSsGU7oW4Ga6YHO6Rt9IF4RdtmIfSxdhIjNCBicyI2TMRGaEDH1vMl+3iyBPZEbIyONkvD6TccbeIGPTeieTuQD9M2MfNuMox+Q8fWwGvDfnx897vtq4S+Ctz+Qdvtvn3c+27z/XPmot5yOrxotDVtF++H9pbEB3sXTo8BSq+dB2Xfv6fPU5puMPFR9+Nul8x1beLkSS+7vY+7u4+7v4O7uECo4fpsWOZNNrSpDeIA3l73po63nXRJbx7q5fJLSh3P5ZpzsJ/npYLZrlbmhiDDmBuGOHFyJhPG7HwzBDxZK9xSaECkPTIcz8Fw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
@@ -3435,13 +3192,258 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7ZfbbsIwDIbfJde9iB07B15lmqYCHapUFVRg0oR49yWMEA4pCI2dpN5Udfo7tj+nTboR02q8nr3U7et8KUZPG9HMJ+Wqnrfe2gig3dhyUbbBXK7KbiVGSNYVomqn/paZtoV4rZtKjABhW1yqkWRUo8aD2mFGrKTjvViBttfFwI5pr/b3R3I0NpcJoI6ZAHFSO87NrrSKkxPIE/VzIYAHNH1o9ICmD43Jo0GV0PANNAQ6giSUSa0/I9hvj+ByEUDZVPgR1NDpS7E2bKJaG5s4ca4FninG/hqAm/0Fk/qr5I3+gmabUjFf6y/KgU0vGxjY9LLBgU0vG/XX2fzefoI0sOllw49g4+SBjVXmBhsTVz2pRMaH2aWjH5COpdQq6+h6OuCcOryGzvHJRp6Db1yib/F830fz3wuwP10ASqkPx1iJoK4X4CuMcwPaowVE22dvjbu6aerZy8kvmgwXyi51VrCfjo0+X46k73cx97vY+13cnS7egt3PataRTPxcaaQzpN58K7u6HDdVYBmerttJROvN1fsiPonwF918Uk3XXRXakDoQ9ij/YSQMB+RwCGQoWKfcwhBCgX5o6yN/AA==",
+      "debug_symbols": "7ZfbjuIwDIbfJde9iB3bSXiV1WhUoDOqVBVUYKUV4t03QYQAmw5CO0epNyhO/yT2Z9O4e7Vs5rvX57Z/WW3U7NdedatFvW1XfbD2Cug4t1nXfTQ323rYqhky2Uo1/TIMBfBQqZe2a9QMEA7Vv2okndQoWe2xIDba80lsQNzbYmDPdFKH8YUcrS95AijJEyDOai+l3Y2YtDmBvlI/VQp4QjOGRiY0Y2hsEQ05yGjMHTQE4k9qQp0dEj6e4D78BF86AYzLgV9AZSpREsupGMLYZU7sSvkVgym/FuBufsHm/Bp9J78g7LIr9v/yi3piM8oGJjajbHBiM8rGfHc2X3efIE1sRtnwe7Dx+szGGXuHjU1VTyaTCccc3ZF3cMdRTpXz9LY74L05/w2956uLvATf+kzf4e29j/anB+A+OwDUWs5trMaLxqsYQIgw7Q3oLgqIDk/Bmg9t17Wvz1efaDr+ULHU2aSej63cliPJ40vs40vc40v8g0uCBceP1eJCsul1JUg3SIP5ux7aet41kWV8uusXCW0wt3/W6UmCvx5Wi2a5G5qYhpyBeEeFFyNhbJBjE8hQsWTf4hRChWHqEE7+Cw==",
       "brillig_names": [
         "store_in_execution_cache_oracle_wrapper",
         "notify_enqueued_public_function_call_wrapper"
       ],
       "verification_key": "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"
     },
+    {
+      "name": "public_dispatch",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "public"
+      ],
+      "abi": {
+        "parameters": [
+          {
+            "name": "selector",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null,
+        "error_types": {
+          "1433889167918961673": {
+            "error_kind": "fmtstring",
+            "length": 17,
+            "item_types": []
+          },
+          "2242946026394210301": {
+            "error_kind": "string",
+            "string": "Block number mismatch."
+          },
+          "2830029349304997821": {
+            "error_kind": "fmtstring",
+            "length": 27,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8209322232883590150": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called internally"
+          },
+          "8443716675528357851": {
+            "error_kind": "string",
+            "string": "Timestamp mismatch."
+          },
+          "10421965853029650238": {
+            "error_kind": "string",
+            "string": "Function _check_block_number can only be called statically"
+          },
+          "11405868724477732285": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called internally"
+          },
+          "13418685691864489983": {
+            "error_kind": "string",
+            "string": "Function _check_timestamp can only be called statically"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "public_dispatch"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [
+        "aztec::macros::functions::utility"
+      ],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "576755928210959028": {
+            "error_kind": "string",
+            "string": "0 has a square root; you cannot claim it is not square"
+          },
+          "2588366281349374274": {
+            "error_kind": "fmtstring",
+            "length": 136,
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            ]
+          },
+          "2709101749560550278": {
+            "error_kind": "string",
+            "string": "Cannot serialize point at infinity as bytes."
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "3305101268118424981": {
+            "error_kind": "string",
+            "string": "Attempted to delete past the length of a CapsuleArray"
+          },
+          "3367683922240523006": {
+            "error_kind": "fmtstring",
+            "length": 58,
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "3473764466780631008": {
+            "error_kind": "fmtstring",
+            "length": 106,
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            ]
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "5533887251808526417": {
+            "error_kind": "fmtstring",
+            "length": 120,
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            ]
+          },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
+          "5870202753060865374": {
+            "error_kind": "fmtstring",
+            "length": 61,
+            "item_types": [
+              {
+                "kind": "field"
+              },
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "6485997221020871071": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          },
+          "6753155520859132764": {
+            "error_kind": "string",
+            "string": "Failed to deliver note"
+          },
+          "7233212735005103307": {
+            "error_kind": "string",
+            "string": "attempt to multiply with overflow"
+          },
+          "8830323656616886390": {
+            "error_kind": "string",
+            "string": "Got a public log emitted by a different contract"
+          },
+          "12099279057757775880": {
+            "error_kind": "string",
+            "string": "DST_LEN too large for offset"
+          },
+          "13649294680379557736": {
+            "error_kind": "string",
+            "string": "extend_from_bounded_vec out of bounds"
+          },
+          "14225679739041873922": {
+            "error_kind": "string",
+            "string": "Index out of bounds"
+          },
+          "14514982005979867414": {
+            "error_kind": "string",
+            "string": "attempt to bit-shift with overflow"
+          },
+          "14657895983200220173": {
+            "error_kind": "string",
+            "string": "Attempted to read past the length of a CapsuleArray"
+          },
+          "15366650908120444287": {
+            "error_kind": "fmtstring",
+            "length": 48,
+            "item_types": [
+              {
+                "kind": "field"
+              },
+              {
+                "kind": "field"
+              }
+            ]
+          },
+          "16218014537381711836": {
+            "error_kind": "string",
+            "string": "Value does not fit in field"
+          },
+          "16446004518090376065": {
+            "error_kind": "string",
+            "string": "Input length must be a multiple of 32"
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "length": 40,
+            "item_types": []
+          },
+          "16954218183513903507": {
+            "error_kind": "string",
+            "string": "Attempted to read past end of BoundedVec"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "_check_block_number",
       "is_unconstrained": true,
@@ -3495,7 +3497,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCLgiASQABLgiASgACJQAAAFIlAAAAfSgCAAEEgEsnAgIEADsNAAEAAigAgEMCAAQoAIBEAgAGKACARQIAASgAgEYCAAIoAIBHAgAFKACASAIAAyYlAAADQR4CAAQBHgIABQAKOAQFBiQCAAYAAACeJQAAA2oeAgAECScCBQABCjgEBQYkAgAGAAAAuiUAAAN8HgIABAUKOAQCBQw4BAIGCygAAYBFAAInAgQBASQCAAIAAAMqIwAAAOMLKAABgEYABxYMBQgkAgAHAAADGCMAAAD8CygAAYBIAAkkAgAJAAADBiMAAAERCygAAYBDAAokAgAKAAAC7yMAAAEmCygAAYBHAAoWDAYLJAIACgAAAtgjAAABPwsoAAGARAAIJAIACAAAAsYjAAABVCcCAQJ2JwIIAm8nAgoCaScCCwJlJwIMAiAnAg0CbCcCDgJuJwIPAnQnAhACcCcCEQJkJwISAmEnAhMCSScCFAJyLQgBFScCFgQSABABFgEnAxUEAQAoFQIWLQwWFy0OExcAKBcCFy0ODhcAKBcCFy0OARcAKBcCFy0OEhcAKBcCFy0ODRcAKBcCFy0OChcAKBcCFy0OERcAKBcCFy0ODBcAKBcCFy0OCBcAKBcCFy0OEBcAKBcCFy0OCxcAKBcCFy0OFBcAKBcCFy0OEhcAKBcCFy0ODxcAKBcCFy0OChcAKBcCFy0OCBcAKBcCFy0ODhcnAgEEACcCCAEACjgIBAokAgAKAAACvScCCwQTLQgBDCcCDQQTABABDQEtDAwNKgMADQUT5jKZ5RcUCQAoDQINACgVAg4nAg8EES4EAA6AAy4EAA2ABC4EAA+ABSUAAAOOJwIOBBEAOA0ODS0OAQ0AKA0CDTwNDAstDAgGIwAAAs8tDAsGIwAAAs8tDAYFIwAAAuYEOAsIAS0MAQUjAAAC5i0MBQkjAAAC/RI4BgUBLQwBCSMAAAL9LQwJByMAAAMPLQwGByMAAAMPLQwHAiMAAAMhLQwIAiMAAAMhLQwCAyMAAAMzLQwFAyMAAAMzJAIAAwAAA0AlAAAD1CYoAIAEBHgADQAAAIAEgAMkAIADAAADaSoBAAEF96Hzr6Wt1Mo8AQECJioBAAEFce1fE3G+NAY8AQECJioBAAEFkKJCubMVTz48AQECJgEAgAOABYAHLgCAA4AILgCABIAJCwCACIAHgAokAIAKAAAD0y4BgAiABi4CgAaACQEAgAgAAoAIAQCACQACgAkjAAADoiYqAQABBR8gi4cBmc/9PAEBAiY=",
-      "debug_symbols": "zVrbTuMwEP2XPOfBM56b+ZUVQgUCqlS1qJSVVoh/3wTqtDQppW1G8gtq0EzPmWOfsev4vXps7t+e7+bLp9VrdfPnvVqsHmab+WrZPr1/1NX9er5YzJ/v9v9dhe4PxPCZ8PoyW3bPr5vZelPdQBTUumqWj5+fidsveZovmvYJ4aMexJNF2oaTEfbRIiPBxorbYGPT/eDbumXERxgx7BgpnGIkksNJNJxiFLhnhHDIiH6jkcZvjD7z+LI8jhfm2WgeAYecR6B4QjmFkLbhCsg/K5dQ8lgmND5UTuJvGNGgErHL8vRCPIML82Q0T2I/UMK7Cc40oqAEy3NPQkonJqpFyxPVOB3KncbLEEw9HbWf6cSUASjsQsHSF4BcDUAoGSDiN4CR2RUtt5VEQfeix5hzTz1KkF2wjgVDyiMbEeDnYICgeYzaz2lfl04WDNfrTtTrvj/PvnRH1KsBGHLBHHUAcKTpngOgIY+VxjAAYLy+AqXeKEOAI9Y/B0BizAAyBEjkK1EM10ukms1lIQ4AIDkDHFkoJwRgZwD2roC9KxDvCsS7AvWuQL0rMO8KzLuC5F1Bcq6AQvAGcK/AuV0TkDeAdwXoXQF6VxCjN4A6AxB6A4gzAIM3gHer8F70SbyNJt5GU2+jqTkDmLfRzLtVJG+jJedWwd67CvbeVbD3roK9dxUMzkZjjN4AzkbjiN4A3kYj8AbwNpr3UQKzt9HYu1WIt9HEu1Wot9HUu1XY9UYzyuempt+PNUfI5NdFujuEJv1iIqUwScVokkrRRAIVwySVwgRiMUysFCZYjCYT7LImYjLBe5GpmHApTLgYTbgYTaSUdUekGO9oMf1Ei+mxVowmVowmCYthUop3FCf4+UP91w/vROgEJ+fS828n0yGAnf0GqUs6e+G//Wif/s7W89n9otnemXx6Wz7sXaHc/HtpDm5TvqxXD83j27rp7lXurlR23gSFGgxaMtAtc8CpBqHusRMMxGrQ0KK2yP8B",
+      "debug_symbols": "zVrbbuIwEP2XPOfBY8/N/ZVVVdE2rZAQVJSutEL8+zotDpcEKJCR/IIImsk5c+IzNo7X1Wvz/PX+NJ2/LT6rhz/rarZ4maymi3m6Wm/q6nk5nc2m70/7P1eu/YDgvhM+Pybz9vpzNVmuqgeAGLWumvlr+u4dcLrJ23TWtFewqXvxqAG34ajou2jmgWAl8dtgJZX94Mc6MaJBRt55v2O0h3GCETNkRizuEiNHHaP2doeM8DcaIR4w+s6j2/Io3Jinw8qlkro8wnBBOQEXt+GS4s8rFz3npxK90rFyHH7DiHqVsN6WJzfiKdyYx4N5HCSnMe0GOOGAguw0jz12MV4YqBryEFCleCx3HC6DfezoiJ6nE7oxhm4XCtH9APDdAOg5AwR/ADAwuoLmthLR7YQEHWJOHfXAbq9jyVBwAszBHuB8MICT/IzS96j7RJIsqUHeLwt2ugse6+693A1AkAumID2AE033GgBx+VlJcD0A8vdXINgZpQ9wwvrXAHAIGYD7ABFtJQrufolEsrnUhR4ARGOAExPliABkDEDWFZB1BWxdAVtXINYViHUFal2BWlcQrSuIxhWgc9YA5hUYt2sEtAawrsBbV+CtKwjBGkCMAdBbA7AxAIE1gHWrsJ70ka2NxtZGE2ujiRoDqLXR1LpVRGujReNWQdarCrJeVZD1qoKsVxUExkYjH6wBjI1GwVsDWBsNwRrA2mjWWwlE1kYj61bB1kZj61Yh1kYT61ah9xtNMe+bqhxuaw6Qya+LZLcJjfLDhEthEovRJJaiCTsshkkshQmEYphoKUx8MZqMsMoaickI70XGYkKlMKFiNKFiNOFS5h3mYrwjxfQTKabHajGaaDGaRF8Mk1K8I36Evz/Y3b5/JkJG2Dnnjn8aTMcAevUbpDbp6on/cZOu/k6W08nzrNmemXz7mr/sHaFc/ftojk5TfiwXL83r17Jpz1XujlS23gSBGhQSGWinOaBYA2N72QoGrDWIS6gJ+T8=",
       "brillig_names": [
         "_check_block_number"
       ]
@@ -3555,7 +3557,7 @@
         }
       },
       "bytecode": "JwACBAEoAAABBIBLJwAABAMnAgMEAicCBAQAHxgABAADgEkdAIBJgEkCHQCASoBKBS4IgEkAAS4IgEoAAiUAAABZJQAAAIQoAgABBIBLJwICBAA7DQABAAIoAIBDAgAEKACARAIABigAgEUCAAEoAIBGAgACKACARwIABSgAgEgCAAMmJQAAA1IeAgAEAR4CAAUACjgEBQYkAgAGAAAApSUAAAN7HgIABAknAgUAAQo4BAUGJAIABgAAAMElAAADjR4CAAQGHAwEBQAcDAIEAAo4BQQCDDgFBAYLKAABgEUABCcCBQEBJAIABAAAAzsjAAAA9AsoAAGARgAHFgwCCCQCAAcAAAMpIwAAAQ0LKAABgEgACSQCAAkAAAMXIwAAASILKAABgEMACiQCAAoAAAMAIwAAATcLKAABgEcAChYMBgskAgAKAAAC6SMAAAFQCygAAYBEAAgkAgAIAAAC1yMAAAFlJwIBAkknAggCZCcCCgJhJwILAnInAgwCbycCDQJpJwIOAnYnAg8CZScCEAIgJwIRAmwnAhICbicCEwJ0JwIUAnAtCAEVJwIWBBIAEAEWAScDFQQBACgVAhYtDBYXLQ4BFwAoFwIXLQ4SFwAoFwIXLQ4OFwAoFwIXLQ4KFwAoFwIXLQ4RFwAoFwIXLQ4NFwAoFwIXLQ4IFwAoFwIXLQ4QFwAoFwIXLQ4MFwAoFwIXLQ4UFwAoFwIXLQ4PFwAoFwIXLQ4LFwAoFwIXLQ4KFwAoFwIXLQ4TFwAoFwIXLQ4NFwAoFwIXLQ4MFwAoFwIXLQ4SFycCAQEAJwIIBAAKOAEFCiQCAAoAAALOJwILBBMtCAEMJwINBBMAEAENAS0MDA0qAwANBRPmMpnlFxQJACgNAg0AKBUCDicCDwQRLgQADoADLgQADYAELgQAD4AFJQAAA58nAg4EEQA4DQ4NLQ4IDQAoDQINPA0MCy0MAQYjAAAC4C0MCwYjAAAC4C0MBgIjAAAC9wQ4CwgBLQwBAiMAAAL3LQwCCSMAAAMOEjgGAgEtDAEJIwAAAw4tDAkHIwAAAyAtDAYHIwAAAyAtDAcEIwAAAzItDAgEIwAAAzItDAQDIwAAA0QtDAIDIwAAA0QkAgADAAADUSUAAAPlJigAgAQEeAANAAAAgASAAyQAgAMAAAN6KgEAAQX3ofOvpa3UyjwBAQImKgEAAQWeScksjTulvTwBAQImKgEAAQW6OL+KoDMf/zwBAQImAQCAA4AFgAcuAIADgAguAIAEgAkLAIAIgAeACiQAgAoAAAPkLgGACIAGLgKABoAJAQCACAACgAgBAIAJAAKACSMAAAOzJioBAAEFdS4blGTo99s8AQECJg==",
-      "debug_symbols": "zVrdTuswDH6XXu/CTuzY5lWOEBow0KRpQ2Mc6Qjx7qeFpS20bLDWUm4Q3ex+P8uXZlleq/vV7cvjzXr7sHuurv68Vpvd3fKw3m3rq9e3RXW7X28268eb/ssVNH8wynvD89Ny21w/H5b7Q3WFMQVZVKvt/fv/xPVNHtabVX0V8G0xqCeNdCwnpdBWpzRSrCzhWKys0i++XlRI4RtGjB0jwXOMUsrllATOMQJuGQUcMPqJRxI/MWr6OFzWl+DCPh7tI2TIfYQSzjgnCHYsFwx82jkLKX+WFpS/OifwE0Y0UCJ8WZ9eiKd6WZ/FsT6T/DmZdT1MI/6lwPFYm0KiM8PUIKdMLYSvZpueJoMA3GdT9wQYFYAQ26wBDZvG3YJ2KCBCOK07muZ0gna2qr0DYJwMQCFlgBg+AYwM4qjZVyOQXvUYc26pxwSpK5axYrQ8gGJAPF1cixLuBFrflw9bpvtO1PreH85H34kmAzBmwRxlAPDNjPgbAGkzIBEGAMmmK5AMkGAIYDAZIMU28mkAEBF9LaqH5HQAyeFSiAOAmJwBWJwBUvAG8FYg3grEW4F6K1BvBeatwJwVEARvAG8F6K0AvRUEbwXBebqmiN4A3grIWwF5K2DwBiBvAOdlC6XoDaDOAN4PffJ+6JN6B029g2beQTP2BnAOGgN5AzgHjTF6AzgHjb1XFey9qmDvVQVH56AxgTeAd9DIe6pg76Cx91ThvZXA3lsJLN5BE++pQr2Dpt5ThXoHzbynCpseNKW8b6ryeVtzhEy+rXSb0CQNkwSxGCbFeILFeBKwGCapFCYRimHCpTChYjyZYZU1E5MZfheZickMq565mBTjiRTjiRTz3NFismPFzCdWyhwrUIonAuV4YqUwwVKyIzTD1x9qbz88EyEz7Jynln/SwYEj/fUvSE3Trx/812/11d/lfr283ayORzMfXrZ3vZOah39Pqy+HNp/2u7vV/ct+1Rzf7E5uNit2FFqgUk0Gm6hijYxJmstmFY3K9btSo9bI/wE=",
+      "debug_symbols": "zVrdTuswDH6XXu/CTuzY4VWOEBow0KRpoDGOdIR495OitRtrGbD1k3KDKNj9fujnhixvzf3i9vXxZrl+eHpprv68Naunu/l2+bQuV2/vs+Z2s1ytlo83hz9uqP3C0T4aXp7n6/b6ZTvfbJsr5px91izW9+X7QJzKTR6Wq0V7xe+zQb14lF25uIS+OqWRYlcLu2JXt8Pi61nDEkYZBQphz+gA4wtGKXHHKBl9x4i0Z9Te7ojRTzwS+cSo7dNwXl+iM/t03Lkiqe9Tid84Z0x5V26l/rRzOaTur5KD67FzRj9hpAMlpuf1+Zl47uf15TjWl806T/L+r6Qy4l8KGne1KST55jHN1KXMcwjHZmc/TYaJ9JBN6Qk0KoAp9rpJhk3jblH/KDBTOK079o+ykO9tzfQBwPFiAAmpA4jhE8DIQxy98zUL7QcS+xhz7anHRAeD0caKC2BXHJhPFxdRpnuB2Q+JfNhyue8ive8mA99FLgZQ7gRrtAHAFxPxNwDWZ8AiDQBSvlyBdQCJhgCZLgZIsY98GgBEZqxF5ZG8HMC6cDnFAUBMYAA1MEAKaAC0AkMrMLQCRytwtIKMVpDBCoQCGgCtgNEKGK0goBUE8LiWyGgAtAJBKxC0AiU0gKABwMsWSREN4GAA9Etf0C99cXTQHB20jA5aVjQAOGhKggYAB005ogHAQVP0qkLRqwpFryo0goOmQmgAdNAEPSoUHTRFjwr0VoKitxLU0EEz9KhwdNAcPSocHbSMHhX58qC5dPumbp+3NUfIdLe1/Sa0WMskUayGSTWecDWeBK6GSaqFSaRqmGgtTKQaTyZYZU3EZILPRSZiMsGqZyom1Xhi1Xhi1bx3vJrs5GrmSa5lxhrV4olRPZ7kWphwLdkxmeDfH+lvPzwTYRPsnKeef/LBgSP/9SdIbdOvX/zX7+Xq73yznN+uFrujmQ+v67uDk5rbf8+Lo0Obz5unu8X962bRHt/cn9xsV+xsMmOXQobbqHJB5mTtZbuKZtfyWyuoBfk/",
       "brillig_names": [
         "_check_timestamp"
       ]
@@ -3582,19 +3584,17 @@
                   {
                     "name": "value",
                     "type": {
-                      "kind": "integer",
-                      "sign": "unsigned",
-                      "width": 64
+                      "kind": "field"
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::check_timestamp_parameters"
+                "path": "Router::check_block_number_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::check_timestamp_abi"
+          "path": "Router::check_block_number_abi"
         },
         {
           "fields": [
@@ -3642,17 +3642,19 @@
                   {
                     "name": "value",
                     "type": {
-                      "kind": "field"
+                      "kind": "integer",
+                      "sign": "unsigned",
+                      "width": 64
                     }
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::check_block_number_parameters"
+                "path": "Router::_check_timestamp_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::check_block_number_abi"
+          "path": "Router::_check_timestamp_abi"
         },
         {
           "fields": [
@@ -3678,12 +3680,12 @@
                   }
                 ],
                 "kind": "struct",
-                "path": "Router::_check_timestamp_parameters"
+                "path": "Router::check_timestamp_parameters"
               }
             }
           ],
           "kind": "struct",
-          "path": "Router::_check_timestamp_abi"
+          "path": "Router::check_timestamp_abi"
         }
       ]
     }
@@ -3691,7 +3693,7 @@
   "file_map": {
     "113": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/aztec.nr",
-      "source": "use crate::{\n    discovery::private_notes::MAX_NOTE_PACKED_LEN,\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{\n            stub_registry,\n            utils::{create_message_discovery_call, find_and_transform_top_level_unconstrained_fns},\n        },\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    find_and_transform_top_level_unconstrained_fns(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    let message_discovery_call = create_message_discovery_call();\n    quote {\n        unconstrained fn sync_notes() {\n            // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n            // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n            // unconstrained execution context since it will not be available otherwise.\n            let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n            $message_discovery_call\n        }\n    }\n}\n"
+      "source": "use crate::{\n    discovery::private_notes::MAX_NOTE_PACKED_LEN,\n    macros::{\n        dispatch::generate_public_dispatch,\n        functions::{\n            stub_registry,\n            utils::{check_each_fn_macroified, create_message_discovery_call},\n        },\n        notes::{generate_note_export, NOTES},\n        storage::STORAGE_LAYOUT_NAME,\n        utils::{get_trait_impl_method, module_has_storage},\n    },\n};\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `sync_notes` utility function PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n\n    // Functions that don't have #[private], #[public], #[utility], #[contract_library_method], or #[test] are not\n    // allowed in contracts.\n    check_each_fn_macroified(m);\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        let max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (TypeDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The message discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_messages`, \n            /// `do_process_log` and `attempt_note_discovery`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::private_notes::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n                _nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (TypeDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    let message_discovery_call = create_message_discovery_call();\n\n    // TODO(https://github.com/noir-lang/noir/issues/7912): Doing the following unfortunately doesn't work. Once\n    // the issue is fixed uncomment the following and remove the workaround from TS (look for the issue link in the\n    // codebase).\n    // let utility: fn(FunctionDefinition) -> () = crate::macros::functions::utility;\n    // quote {\n    //     #[$utility]\n    //     unconstrained fn sync_notes() {\n    //         $message_discovery_call\n    //     }\n    // }\n\n    quote {\n        #[aztec::macros::functions::utility]\n        unconstrained fn sync_notes() {\n            $message_discovery_call\n        }\n    }\n}\n"
     },
     "114": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/dispatch.nr",
@@ -3699,7 +3701,7 @@
     },
     "121": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
-      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_public, is_fn_view, modify_fn_body, module_has_initializer,\n        module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform message discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $message_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn find_and_transform_top_level_unconstrained_fns(m: Module) {\n    // Top-level unconstrained fns are contract entrypoints, but they're not explicitly designated in any way. They're\n    // the fallback case for a function that matches no other rules.\n    // TODO(#12743): improve this\n\n    // We first find non-standard contract entrypoints, i.e. functions in the `contract` mod that are not private or\n    // public, but which *are* contract entrypoints (i.e. they're not opting out via the #[test] or\n    // #[contract_library_method] attributes). Ideally entrypoints would be explicitly designated instead.\n    let non_private_public_entrypoint_functions = m.functions().filter(|f: FunctionDefinition| {\n        !is_fn_private(f)\n            & !is_fn_public(f)\n            & !f.has_named_attribute(\"contract_library_method\")\n            & !f.has_named_attribute(\"test\")\n    });\n\n    // TODO: uncomment the code below and emit a warning once support for them is added to Noir (tracked in\n    // https://github.com/noir-lang/noir/issues/7714). We can't simply print a message since that'd otherwise break the\n    // output of utils such as `nargo test --list-tests`.\n    // // We don't expect to see any custom constrained entrypoints (i.e. private functions created outside of aztec-nr's\n    // // #[private] macro, possibly resulting in a non-standard interface).\n    // for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n    //     !f.is_unconstrained()\n    // }) {\n    //     let name = f.name();\n    //     warn(\n    //         f\"found private contract function '{name}' which does not have the #[private] attribute - make sure you know what you're doing!\",\n    //     );\n    // }\n\n    // An unconstrained contract entrypoints is what we call a top-level unconstrained function, to which we apply the\n    // appropriate transformation. Ideally these would be explicitly designated as such instead.\n    for f in non_private_public_entrypoint_functions.filter(|f: FunctionDefinition| {\n        f.is_unconstrained()\n    }) {\n        transform_top_level_unconstrained(f);\n    }\n}\n\npub(crate) comptime fn transform_top_level_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform message discovery, since they may need to access private notes that would be\n    // found during this process. This is slightly inefficient and could be improved by only doing it once we actually\n    // attempt to read any.\n    let message_discovery_call = if NOTES.len() > 0 {\n        create_message_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $message_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_messages`, causing for new notes to be added to PXE and made\n/// available for the current execution.\npub(crate) comptime fn create_message_discovery_call() -> Quoted {\n    quote {\n        /// Safety: message discovery returns nothing and is performed solely for its side-effects. It is therefore\n        /// always safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_messages(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            );\n        };\n    }\n}\n"
+      "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"
     },
     "143": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
@@ -3737,43 +3739,43 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "184": {
+    "185": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/append.nr",
       "source": "/// Appends two `BoundedVec`s together, returning one that contains all of the elements of the first one followed by all\n/// of the elements of the second one. The resulting `BoundedVec` can have any arbitrary maximum length, but it must be\n/// large enough to fit all of the elements of both the first and second vectors.\npub fn append<T, let A_LEN: u32, let B_LEN: u32, let DST_LEN: u32>(\n    a: BoundedVec<T, A_LEN>,\n    b: BoundedVec<T, B_LEN>,\n) -> BoundedVec<T, DST_LEN> {\n    let mut dst = BoundedVec::new();\n\n    dst.extend_from_bounded_vec(a);\n    dst.extend_from_bounded_vec(b);\n\n    dst\n}\n\nmod test {\n    use super::append;\n\n    #[test]\n    unconstrained fn append_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::new();\n        let b: BoundedVec<_, 14> = BoundedVec::new();\n\n        let result: BoundedVec<Field, 5> = append(a, b);\n\n        assert_eq(result.len(), 0);\n        assert_eq(result.storage(), std::mem::zeroed());\n    }\n\n    #[test]\n    unconstrained fn append_non_empty_vecs() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let result: BoundedVec<Field, 8> = append(a, b);\n\n        assert_eq(result.len(), 6);\n        assert_eq(result.storage(), [1, 2, 3, 4, 5, 6, std::mem::zeroed(), std::mem::zeroed()]);\n    }\n\n    #[test(should_fail_with = \"out of bounds\")]\n    unconstrained fn append_non_empty_vecs_insufficient_max_len() {\n        let a: BoundedVec<_, 3> = BoundedVec::from_array([1, 2, 3]);\n        let b: BoundedVec<_, 14> = BoundedVec::from_array([4, 5, 6]);\n\n        let _: BoundedVec<Field, 5> = append(a, b);\n    }\n}\n"
     },
-    "186": {
+    "187": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/mod.nr",
       "source": "pub mod append;\npub mod collapse;\npub mod subarray;\npub mod subbvec;\n\npub use append::append;\npub use collapse::collapse;\npub use subarray::subarray;\npub use subbvec::subbvec;\n\n// This will eventually be replaced by `BoundedVec::for_each`, once that's implemented.\npub unconstrained fn for_each_in_bounded_vec<T, let MaxLen: u32, Env>(\n    vec: BoundedVec<T, MaxLen>,\n    f: fn[Env](T, u32) -> (),\n) {\n    for i in 0..vec.len() {\n        f(vec.get_unchecked(i), i);\n    }\n}\n"
     },
-    "187": {
+    "188": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "188": {
+    "189": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
       "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n    bvec: BoundedVec<T, SRC_MAX_LEN>,\n    offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(bvec.storage(), offset), bvec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
     },
-    "189": {
+    "190": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/comparison.nr",
       "source": "struct ComparatorEnum {\n    pub EQ: u8,\n    pub NEQ: u8,\n    pub LT: u8,\n    pub LTE: u8,\n    pub GT: u8,\n    pub GTE: u8,\n}\n\npub global Comparator: ComparatorEnum =\n    ComparatorEnum { EQ: 1, NEQ: 2, LT: 3, LTE: 4, GT: 5, GTE: 6 };\n\npub fn compare(lhs: Field, operation: u8, rhs: Field) -> bool {\n    // Values are computed ahead of time because circuits evaluate all branches\n    let is_equal = lhs == rhs;\n    let is_lt = lhs.lt(rhs);\n\n    if (operation == Comparator.EQ) {\n        is_equal\n    } else if (operation == Comparator.NEQ) {\n        !is_equal\n    } else if (operation == Comparator.LT) {\n        is_lt\n    } else if (operation == Comparator.LTE) {\n        is_lt | is_equal\n    } else if (operation == Comparator.GT) {\n        !is_lt & !is_equal\n    } else if (operation == Comparator.GTE) {\n        !is_lt\n    } else {\n        panic(f\"Invalid operation\")\n    }\n}\n\nmod test {\n    use super::Comparator;\n    use super::compare;\n\n    #[test]\n    unconstrained fn test_compare() {\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(compare(lhs, Comparator.LT, rhs), \"Expected lhs to be less than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.LTE, rhs), \"Expected lhs to be less than or equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(compare(lhs, Comparator.GT, rhs), \"Expected lhs to be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(!compare(lhs, Comparator.EQ, rhs), \"Expected lhs to be not equal to rhs\");\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.NEQ, rhs), \"Expected lhs to not be not equal to rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.LT, rhs), \"Expected lhs to not be less than rhs\");\n\n        let lhs = 11;\n        let rhs = 10;\n        assert(\n            !compare(lhs, Comparator.LTE, rhs),\n            \"Expected lhs to not be less than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 10;\n        assert(!compare(lhs, Comparator.GT, rhs), \"Expected lhs to not be greater than rhs\");\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n\n        let lhs = 10;\n        let rhs = 11;\n        assert(\n            !compare(lhs, Comparator.GTE, rhs),\n            \"Expected lhs to not be greater than or equal to rhs\",\n        );\n    }\n}\n"
     },
-    "190": {
+    "191": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/bytes_to_fields.nr",
       "source": "use std::static_assert;\n\n// These functions are used to facilitate the conversion of log ciphertext between byte and field representations.\n//\n// `bytes_to_fields` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `bytes_from_fields` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between bytes and fields when processing encrypted logs.\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole\n/// bytes. Use `bytes_from_fields` to obtain the original bytes array.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (31 bytes) is encoded as [1 * 256^30 + 10 * 256^29 + 3 * 256^28 + ... + 0]\n/// Note: N must be a multiple of 31 bytes\npub fn bytes_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; N / 31] {\n    // Assert that N is a multiple of 31\n    static_assert(N % 31 == 0, \"N must be a multiple of 31\");\n\n    let mut fields = [0; N / 31];\n\n    // Since N is a multiple of 31, we can simply process all chunks fully\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    fields\n}\n\n/// Converts an input BoundedVec of fields into a BoundedVec of bytes in big-endian order. Arbitrary Field arrays\n/// are not allowed: this is assumed to be an array obtained via `bytes_to_fields`, i.e. one that actually represents\n/// bytes. To convert a Field array into bytes, use `fields_to_bytes`.\n///\n/// Each input field must contain at most 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte chunks are concatenated\n/// back together in the order of the original fields.\npub fn bytes_from_fields<let N: u32>(fields: BoundedVec<Field, N>) -> BoundedVec<u8, N * 31> {\n    let mut bytes = BoundedVec::new();\n\n    for i in 0..fields.len() {\n        let field = fields.get(i);\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n        for j in 0..31 {\n            bytes.push(field_as_bytes[j]);\n        }\n    }\n\n    bytes\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{bytes_from_fields, bytes_to_fields};\n\n    #[test]\n    unconstrained fn random_bytes_to_fields_and_back(input: [u8; 93]) {\n        let fields = bytes_to_fields(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `bytes_from_fields`\n        // function.\n        let fields_as_bounded_vec = BoundedVec::<_, 6>::from_array(fields);\n\n        let bytes_back = bytes_from_fields(fields_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(bytes_back.len(), input.len());\n        assert_eq(subarray(bytes_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"N must be a multiple of 31\")]\n    unconstrained fn bytes_to_fields_input_length_not_multiple_of_31() {\n        // Try to convert 32 bytes (not a multiple of 31) to fields\n        let _fields = bytes_to_fields([0; 32]);\n    }\n\n}\n"
     },
-    "191": {
+    "192": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/conversion/fields_to_bytes.nr",
       "source": "// These functions are used to facilitate the conversion of log plaintext represented as fields into bytes and back.\n//\n// `fields_to_bytes` uses fixed-size arrays since encryption contexts have compile-time size information.\n// `fields_from_bytes` uses BoundedVec for flexibility in unconstrained contexts where sizes are dynamic.\n//\n// Together they provide bidirectional conversion between fields and bytes.\n\n/// Converts an input array of fields into a single array of bytes. Use `fields_from_bytes` to obtain the original\n/// field array.\n/// Each field is converted to a 32-byte big-endian array.\n///\n/// For example, if you have a field array [123, 456], it will be converted to a 64-byte array:\n/// [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,123,  // First field (32 bytes)\n///  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,200]  // Second field (32 bytes)\n///\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end, every 32 bytes. Be careful\n/// that such a gap doesn't leak information! This could happen if you for example expected the output to be\n/// indistinguishable from random bytes.\npub fn fields_to_bytes<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n\n    for i in 0..N {\n        let field_as_bytes: [u8; 32] = fields[i].to_be_bytes();\n\n        for j in 0..32 {\n            bytes[i * 32 + j] = field_as_bytes[j];\n        }\n    }\n\n    bytes\n}\n\n/// Converts an input BoundedVec of bytes into a BoundedVec of fields. Arbitrary byte arrays are not allowed: this\n/// is assumed to be an array obtained via `fields_to_bytes`, i.e. one that actually represents fields. To convert\n/// a byte array into Fields, use `bytes_to_fields`.\n///\n/// The input bytes are chunked into chunks of 32 bytes. Each 32-byte chunk is viewed as big-endian, and is converted\n/// into a Field.\n/// For example, [1, 10, 3, ..., 0] (32 bytes) is encoded as [1 * 256^31 + 10 * 256^30 + 3 * 256^29 + ... + 0]\n/// Note 1: N must be a multiple of 32 bytes\n/// Note 2: The max value check code was taken from std::field::to_be_bytes function.\npub fn fields_from_bytes<let N: u32>(bytes: BoundedVec<u8, N>) -> BoundedVec<Field, N / 32> {\n    // Assert that input length is a multiple of 32\n    assert(bytes.len() % 32 == 0, \"Input length must be a multiple of 32\");\n\n    let mut fields = BoundedVec::new();\n\n    let p = std::field::modulus_be_bytes();\n\n    // Since input length is a multiple of 32, we can simply process all chunks fully\n    for i in 0..bytes.len() / 32 {\n        let mut field = 0;\n\n        // Process each byte in the 32-byte chunk\n        let mut ok = false;\n\n        for j in 0..32 {\n            let next_byte = bytes.get(i * 32 + j);\n            field = field * 256 + next_byte as Field;\n\n            if !ok {\n                if next_byte != p[j] {\n                    assert(next_byte < p[j], \"Value does not fit in field\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"Value does not fit in field\");\n\n        fields.push(field);\n    }\n\n    fields\n}\n\nmod tests {\n    use crate::utils::array::subarray;\n    use super::{fields_from_bytes, fields_to_bytes};\n\n    #[test]\n    unconstrained fn random_fields_to_bytes_and_back(input: [Field; 3]) {\n        // Convert to bytes\n        let bytes = fields_to_bytes(input);\n\n        // At this point in production, the log flies through the system and we get a BoundedVec on the other end.\n        // So we need to convert the field array to a BoundedVec to be able to feed it to the `fields_from_bytes`\n        // function.\n        // 113 is an arbitrary max length that is larger than the input length of 96.\n        let bytes_as_bounded_vec = BoundedVec::<_, 113>::from_array(bytes);\n\n        // Convert back to fields\n        let fields_back = fields_from_bytes(bytes_as_bounded_vec);\n\n        // Compare the original input with the round-tripped result\n        assert_eq(fields_back.len(), input.len());\n        assert_eq(subarray(fields_back.storage(), 0), input);\n    }\n\n    #[test(should_fail_with = \"Input length must be a multiple of 32\")]\n    unconstrained fn to_fields_assert() {\n        // 143 is an arbitrary max length that is larger than 33\n        let input = BoundedVec::<_, 143>::from_array([\n            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,\n        ]);\n\n        // This should fail since 33 is not a multiple of 32\n        let _fields = fields_from_bytes(input);\n    }\n\n    #[test]\n    unconstrained fn fields_from_bytes_max_value() {\n        let max_field_as_bytes: [u8; 32] = (-1).to_be_bytes();\n        let input = BoundedVec::<_, 32>::from_array(max_field_as_bytes);\n\n        let fields = fields_from_bytes(input);\n\n        // The result should be a largest value storable in a field (-1 since we are modulo-ing)\n        assert_eq(fields.get(0), -1);\n    }\n\n    // In this test we verify that overflow check works by taking the max allowed value, bumping a random byte\n    // and then feeding it to `fields_from_bytes` as input.\n    #[test(should_fail_with = \"Value does not fit in field\")]\n    unconstrained fn fields_from_bytes_overflow(random_value: u8) {\n        let index_of_byte_to_bump = random_value % 32;\n\n        // Obtain the byte representation of the maximum field value\n        let max_field_value_as_bytes: [u8; 32] = (-1).to_be_bytes();\n\n        let byte_to_bump = max_field_value_as_bytes[index_of_byte_to_bump];\n\n        // Skip test execution if the selected byte is already at maximum value (255).\n        // This is acceptable since we are using fuzz testing to generate many test cases.\n        if byte_to_bump != 255 {\n            let mut input = BoundedVec::<_, 32>::from_array(max_field_value_as_bytes);\n\n            // Increment the selected byte to exceed the field's maximum value\n            input.set(index_of_byte_to_bump as u32, byte_to_bump + 1);\n\n            // Attempt the conversion, which should fail due to the value exceeding the field's capacity\n            let _fields = fields_from_bytes(input);\n        }\n    }\n\n}\n"
     },
-    "193": {
+    "194": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/field.nr",
       "source": "use std::option::Option;\n\nglobal KNOWN_NON_RESIDUE: Field = 5; // This is a non-residue in Noir's native Field.\n\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\nunconstrained fn is_square(x: Field) -> bool {\n    let v = pow(x, -1 / 2);\n    v * (v - 1) == 0\n}\n\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\nunconstrained fn tonelli_shanks_sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\n// NB: this doesn't return an option, because in the case of there _not_ being a square root, we still want to return a field element that allows us to then assert in the _constrained_ sqrt function that there is no sqrt.\npub unconstrained fn __sqrt(x: Field) -> (bool, Field) {\n    let is_sq = is_square(x);\n    if is_sq {\n        let sqrt = tonelli_shanks_sqrt(x);\n        (true, sqrt)\n    } else {\n        // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n        // Facts:\n        // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n        // - If x is a square, LS(x) = 1\n        // - If x is not a square, LS(x) = -1\n        // - If x = 0, LS(x) = 0.\n        //\n        // Hence:\n        // sq * sq = sq // 1 * 1 = 1\n        // non-sq * non-sq = sq // -1 * -1 = 1\n        // sq * non-sq = non-sq // -1 * 1 = -1\n        //\n        // See: https://en.wikipedia.org/wiki/Legendre_symbol\n        let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n        let not_sqrt = tonelli_shanks_sqrt(demo_x_not_square);\n        (false, not_sqrt)\n    }\n}\n\n// Returns (false, 0) if there is no square root.\n// Returns (true, sqrt) if there is a square root.\npub fn sqrt(x: Field) -> Option<Field> {\n    // Safety: if the hint returns the square root of x, then we simply square it\n    // check the result equals x. If x is not square, we return a value that\n    // enables us to prove that fact (see the `else` clause below).\n    let (is_sq, maybe_sqrt) = unsafe { __sqrt(x) };\n\n    if is_sq {\n        let sqrt = maybe_sqrt;\n        validate_sqrt_hint(x, sqrt);\n        Option::some(sqrt)\n    } else {\n        let not_sqrt_hint = maybe_sqrt;\n        validate_not_sqrt_hint(x, not_sqrt_hint);\n        Option::none()\n    }\n}\n\nfn validate_sqrt_hint(x: Field, hint: Field) {\n    assert(hint * hint == x, f\"The claimed_sqrt {hint} is not the sqrt of x {x}\");\n}\n\nfn validate_not_sqrt_hint(x: Field, hint: Field) {\n    // We need this assertion, because x = 0 would pass the other assertions in this\n    // function, and we don't want people to be able to prove that 0 is not square!\n    assert(x != 0, \"0 has a square root; you cannot claim it is not square\");\n    // Demonstrate that x is not a square (a.k.a. a \"quadratic non-residue\").\n    //\n    // Facts:\n    // The Legendre symbol (\"LS\") of x, is x^((p-1)/2) (mod p).\n    // - If x is a square, LS(x) = 1\n    // - If x is not a square, LS(x) = -1\n    // - If x = 0, LS(x) = 0.\n    //\n    // Hence:\n    // 1. sq * sq = sq // 1 * 1 = 1\n    // 2. non-sq * non-sq = sq // -1 * -1 = 1\n    // 3. sq * non-sq = non-sq // -1 * 1 = -1\n    //\n    // See: https://en.wikipedia.org/wiki/Legendre_symbol\n    //\n    // We want to demonstrate that this below multiplication falls under bullet-point (2):\n    let demo_x_not_square = x * KNOWN_NON_RESIDUE;\n    // I.e. we want to demonstrate that `demo_x_not_square` has Legendre symbol 1\n    // (i.e. that it is a square), so we prove that it is square below.\n    // Why do we want to prove that it has LS 1?\n    // Well, since it was computed with a known-non-residue, its squareness implies we're\n    // in case 2 (something multiplied by a known-non-residue yielding a result which\n    // has a LS of 1), which implies that x must be a non-square. The unconstrained\n    // function gave us the sqrt of demo_x_not_square, so all we need to do is\n    // assert its squareness:\n    assert(\n        hint * hint == demo_x_not_square,\n        f\"The hint {hint} does not demonstrate that {x} is not a square\",\n    );\n}\n\n#[test]\nfn test_sqrt() {\n    let x = 9;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_some());\n    let sqrt = maybe_sqrt.unwrap_unchecked();\n    assert((sqrt == 3) | (sqrt == -3));\n}\n\n#[test]\nfn test_non_square() {\n    let x = 5;\n    let maybe_sqrt = sqrt(x);\n    assert(maybe_sqrt.is_none());\n}\n\n#[test]\nunconstrained fn test_known_non_residue_is_actually_a_non_residue_in_the_field() {\n    assert(!is_square(KNOWN_NON_RESIDUE));\n}\n\n#[test]\nfn test_sqrt_0() {\n    let x = 0;\n    let sqrt = sqrt(x).unwrap();\n    assert(sqrt == 0);\n}\n\n#[test]\nfn test_sqrt_1() {\n    let x = 1;\n    let sqrt = sqrt(x).unwrap();\n    assert((sqrt == 1) | (sqrt == -1));\n}\n\n#[test(should_fail_with = \"The claimed_sqrt 0x04 is not the sqrt of x 0x09\")]\nfn test_bad_sqrt_hint_fails() {\n    validate_sqrt_hint(9, 4);\n}\n\n#[test(should_fail_with = \"The hint 0x04 does not demonstrate that 0x0a is not a square\")]\nfn test_bad_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(10, 4);\n}\n\n#[test(should_fail_with = \"0 has a square root; you cannot claim it is not square\")]\nfn test_0_not_sqrt_hint_fails() {\n    validate_not_sqrt_hint(0, 0);\n}\n\n#[test]\nunconstrained fn test_is_square() {\n    assert(is_square(25));\n}\n\n#[test]\nunconstrained fn test_is_not_square() {\n    assert(!is_square(10));\n}\n"
     },
-    "195": {
+    "196": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::utils::field::sqrt;\nuse dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a point to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(p: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = p.x.to_be_bytes();\n\n    if get_sign_of_point(p) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n    Point { x, y, is_infinite: false }\n}\n\n/// Uses the x coordinate and sign flag (+/-) to reconstruct the point.\n/// The y coordinate can be derived from the x coordinate and the \"sign\" flag by solving the grumpkin curve\n/// equation for y.\n/// @param x - The x coordinate of the point\n/// @param sign - The \"sign\" of the y coordinate - determines whether y <= (Fr.MODULUS - 1) / 2\npub fn point_from_x_coord_and_sign(x: Field, sign: bool) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n\n    // If y > MOD_DIV_2 and we want positive sign (or vice versa), negate y\n    let y_is_positive = !BN254_FR_MODULUS_DIV_2.lt(y);\n    let final_y = if y_is_positive == sign { y } else { -y };\n\n    Point { x, y: final_y, is_infinite: false }\n}\n\nmod test {\n    use crate::utils::point::{point_from_x_coord_and_sign, point_to_bytes};\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_from_x_coord_and_sign() {\n        // Test positive y coordinate\n        let x = 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73;\n        let sign = true;\n        let p = point_from_x_coord_and_sign(x, sign);\n\n        assert_eq(p.x, x);\n        assert_eq(p.y, 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a);\n        assert_eq(p.is_infinite, false);\n\n        // Test negative y coordinate\n        let x2 = 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5;\n        let sign2 = false;\n        let p2 = point_from_x_coord_and_sign(x2, sign2);\n\n        assert_eq(p2.x, x2);\n        assert_eq(p2.y, 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0);\n        assert_eq(p2.is_infinite, false);\n    }\n}\n"
     },
-    "215": {
+    "216": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/abis/event_selector.nr",
       "source": "use crate::traits::{Deserialize, Empty, FromField, Serialize, ToField};\n\npub struct EventSelector {\n    // 1st 4-bytes (big-endian leftmost) of abi-encoding of an event.\n    inner: u32,\n}\n\nimpl Eq for EventSelector {\n    fn eq(self, other: EventSelector) -> bool {\n        other.inner == self.inner\n    }\n}\n\nimpl Serialize<1> for EventSelector {\n    fn serialize(self: Self) -> [Field; 1] {\n        [self.inner as Field]\n    }\n}\n\nimpl Deserialize<1> for EventSelector {\n    fn deserialize(fields: [Field; 1]) -> Self {\n        Self { inner: fields[0] as u32 }\n    }\n}\n\nimpl FromField for EventSelector {\n    fn from_field(field: Field) -> Self {\n        Self { inner: field as u32 }\n    }\n}\n\nimpl ToField for EventSelector {\n    fn to_field(self) -> Field {\n        self.inner as Field\n    }\n}\n\nimpl Empty for EventSelector {\n    fn empty() -> Self {\n        Self { inner: 0 as u32 }\n    }\n}\n\nimpl EventSelector {\n    pub fn from_u32(value: u32) -> Self {\n        Self { inner: value }\n    }\n\n    pub fn from_signature<let N: u32>(signature: str<N>) -> Self {\n        let bytes = signature.as_bytes();\n        let hash = crate::hash::poseidon2_hash_bytes(bytes);\n\n        // `hash` is automatically truncated to fit within 32 bits.\n        EventSelector::from_field(hash)\n    }\n\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n}\n"
     },
@@ -3781,35 +3783,35 @@
       "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"
     },
-    "277": {
+    "278": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "278": {
+    "279": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "292": {
+    "293": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/meta/mod.nr",
       "source": "use super::traits::{Deserialize, Packable, Serialize};\n\n/// Returns the typed expression of a trait method implementation.\n///\n/// This helper function is preferred over directly inlining with `$typ::target_method()` in a quote,\n/// as direct inlining would result in missing import warnings in the generated code (specifically,\n/// warnings that the trait implementation is not in scope).\n///\n/// # Note\n/// A copy of this function exists in `aztec-nr/aztec/src/macros/utils.nr`. We maintain separate copies\n/// because importing it there from here would cause the `target_trait` to be interpreted in the context\n/// of this crate, making it impossible to compile code for traits from that crate (e.g. NoteType).\ncomptime fn get_trait_impl_method(\n    typ: Type,\n    target_trait: Quoted,\n    target_method: Quoted,\n) -> TypedExpr {\n    let trait_constraint = target_trait.as_trait_constraint();\n    typ\n        .get_trait_impl(trait_constraint)\n        .expect(f\"Could not find impl for {target_trait} for type {typ}\")\n        .methods()\n        .filter(|m| m.name() == target_method)[0]\n        .as_typed_expr()\n}\n\n/// Generates code that deserializes a struct, primitive type, array or string from a field array.\n///\n/// # Parameters\n/// - `name`: The name of the current field being processed, used to identify fields for replacement.\n/// - `typ`: The type of the struct or field being deserialized (e.g., a custom struct, array, or primitive).\n/// - `field_array_name`: The name of the field array containing serialized field data (e.g., `\"values\"`).\n/// - `num_already_consumed`: The number of fields already processed in previous recursion calls.\n/// - `should_unpack`: A boolean indicating whether the type should be unpacked (see description of `Packable`\n/// and `Serialize` trait for more information about the difference between packing and serialization).\n///\n/// # Returns\n/// A tuple containing:\n/// - `Quoted`: A code that deserializes a given struct, primitive type, array, or string from the field array.\n/// - `u32`: The total number of fields consumed during deserialization (used for recursion).\n///\n/// # Nested Struct Example\n/// Given the following setup:\n/// ```\n/// struct UintNote {\n///     value: u128,\n///     owner: AztecAddress,\n///     randomness: Field,\n/// }\n///\n/// struct AztecAddress {\n///     inner: Field,\n/// }\n/// ```\n///\n/// If `UintNote` is the input type, the function will generate the following deserialization code:\n/// ```\n/// UintNote {\n///     value: fields[0] as u128,\n///     owner: AztecAddress {\n///         inner: fields[1],\n///     },\n///     randomness: fields[2],\n/// }\n/// ```\n/// # Nested Struct Example with Unpacking\n/// - given the same setup as above and given that u128, AztecAddress and Field implement the `Packable` trait\n///   the result we get is:\n/// ```\n/// UintNote {\n///     value: aztec::protocol_types::traits::Packable::unpack([fields[0]]),\n///     owner: aztec::protocol_types::traits::Packable::unpack([fields[1]]),\n///     randomness: aztec::protocol_types::traits::Packable::unpack([fields[2]]),\n/// }\n/// ```\n///\n/// # Panics\n/// - If the deserialization logic encounters a type it does not support.\n/// - If an incorrect number of fields are consumed when deserializing a string.\npub comptime fn generate_deserialize_from_fields(\n    name: Quoted,\n    typ: Type,\n    field_array_name: Quoted,\n    num_already_consumed: u32,\n    should_unpack: bool,\n) -> (Quoted, u32) {\n    let mut result = quote {};\n    // Counter for the number of fields consumed\n    let mut consumed_counter: u32 = 0;\n\n    // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n    let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n    let packable_constraint = quote { Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n    if (should_unpack & typ.implements(packable_constraint)) {\n        // Unpacking is enabled and the given type implements the `Packable` trait so we call the `unpack()`\n        // method, add the resulting field array to `aux_vars` and each field to `fields`.\n        let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n        // We copy the packed fields into a new array and pass that to the unpack function in a quote\n        let mut packed_fields_quotes = &[];\n        for i in 0..packed_len {\n            let index_in_field_array = i + num_already_consumed;\n            packed_fields_quotes =\n                packed_fields_quotes.push_back(quote { $field_array_name[$index_in_field_array] });\n        }\n        let packed_fields = packed_fields_quotes.join(quote {,});\n\n        // Now we call unpack on the type\n        let unpack_method = get_trait_impl_method(typ, quote { Packable<_> }, quote { unpack });\n        result = quote { $unpack_method([ $packed_fields ]) };\n\n        consumed_counter = packed_len;\n    } else if typ.is_field() | typ.as_integer().is_some() | typ.is_bool() {\n        // The field is a primitive so we just reference it in the field array\n        result = quote { $field_array_name[$num_already_consumed] as $typ };\n        consumed_counter = 1;\n    } else if typ.as_data_type().is_some() {\n        // The field is a struct so we iterate over each struct field and recursively call\n        // `generate_deserialize_from_fields`\n        let (nested_def, generics) = typ.as_data_type().unwrap();\n        let nested_name = nested_def.name();\n        let mut deserialized_fields_list = &[];\n\n        // Iterate over each field in the struct\n        for field in nested_def.fields(generics) {\n            let (field_name, field_type) = field;\n            // Recursively call `generate_deserialize_from_fields` for each field in the struct\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                field_name,\n                field_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `value: u128 { lo: fields[0], hi: fields[1] }`\n            deserialized_fields_list =\n                deserialized_fields_list.push_back(quote { $field_name: $deserialized_field });\n        }\n\n        // We can construct the struct from the deserialized fields\n        let deserialized_fields = deserialized_fields_list.join(quote {,});\n        result = quote {\n                $nested_name {\n                    $deserialized_fields\n                }\n            };\n    } else if typ.as_array().is_some() {\n        // The field is an array so we iterate over each element and recursively call\n        // `generate_deserialize_from_fields`\n        let (element_type, array_len) = typ.as_array().unwrap();\n        let array_len = array_len.as_constant().unwrap();\n        let mut array_fields_list = &[];\n\n        // Iterate over each element in the array\n        for _ in 0..array_len {\n            // Recursively call `generate_deserialize_from_fields` for each element in the array\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                element_type,\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n            // We increment the consumed counter by the number of fields consumed in the recursion\n            consumed_counter += num_consumed_in_recursion;\n            // We add the deserialized field to the list of deserialized fields.\n            array_fields_list = array_fields_list.push_back(deserialized_field);\n        }\n\n        // We can construct the array from the deserialized fields\n        let array_fields = array_fields_list.join(quote {,});\n        result = quote { [ $array_fields ] };\n    } else if typ.as_str().is_some() {\n        // The field is a string and we expect each byte of the string to be represented as 1 field in the field\n        // array. So we iterate over the string length and deserialize each character as u8 in the recursive call\n        // to `generate_deserialize_from_fields`.\n        let length_type = typ.as_str().unwrap();\n        let str_len = length_type.as_constant().unwrap();\n        let mut byte_list = &[];\n\n        // Iterate over each character in the string\n        for _ in 0..str_len {\n            // Recursively call `generate_deserialize_from_fields` for each character in the string\n            let (deserialized_field, num_consumed_in_recursion) = generate_deserialize_from_fields(\n                name,\n                quote {u8}.as_type(),\n                field_array_name,\n                consumed_counter + num_already_consumed,\n                should_unpack,\n            );\n\n            // We should consume just one field in the recursion so we sanity check that\n            assert_eq(\n                num_consumed_in_recursion,\n                1,\n                \"Incorrect number of fields consumed in string deserialization\",\n            );\n\n            // We increment the consumed counter by 1 as we have consumed one field\n            consumed_counter += 1;\n\n            // We add the deserialized field to the list of deserialized fields.\n            // E.g. `fields[6] as u8`\n            byte_list = byte_list.push_back(deserialized_field);\n        }\n\n        // We construct the string from the deserialized fields\n        let bytes = byte_list.join(quote {,});\n        result = quote { [ $bytes ].as_str_unchecked() };\n    } else {\n        panic(\n            f\"Unsupported type for serialization of argument {name} and type {typ}\",\n        )\n    }\n\n    (result, consumed_counter)\n}\n\n/// Generates code that serializes a type into an array of fields. Also generates auxiliary variables if necessary\n/// for serialization. If `should_pack` is true, we check if the type implements the `Packable` trait and pack it\n/// if it does.\n///\n/// # Parameters\n/// - `name`: The base identifier (e.g., `self`, `some_var`).\n/// - `typ`: The type being serialized (e.g., a custom struct, array, or primitive type).\n/// - `omit`: A list of field names (as `Quoted`) to be excluded from the serialized output.\n/// - `should_pack`: A boolean indicating whether the type should be packed.\n///\n/// # Returns\n/// A tuple containing:\n/// - A flattened array of `Quoted` field references representing the serialized fields.\n/// - An array of `Quoted` auxiliary variables needed for serialization, such as byte arrays for strings.\n///\n/// # Examples\n///\n/// ## Struct\n/// Given the following struct:\n/// ```rust\n/// struct MockStruct {\n///     a: Field,\n///     b: Field,\n/// }\n/// ```\n///\n/// Serializing the struct:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_mock_struct }, MockStruct, &[], false)\n/// // Returns:\n/// // ([`my_mock_struct.a`, `my_mock_struct.b`], [])\n/// ```\n///\n/// ## Nested Struct\n/// For a more complex struct:\n/// ```rust\n/// struct NestedStruct {\n///     m1: MockStruct,\n///     m2: MockStruct,\n/// }\n/// ```\n///\n/// Serialization output:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, NestedStruct, &[], false)\n/// // Returns:\n/// // ([`self.m1.a`, `self.m1.b`, `self.m2.a`, `self.m2.b`], [])\n/// ```\n///\n/// ## Array\n/// For an array type:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_array }, [Field; 3], &[], false)\n/// // Returns:\n/// // ([`my_array[0]`, `my_array[1]`, `my_array[2]`], [])\n/// ```\n///\n/// ## String\n/// For a string field, where each character is serialized as a `Field`:\n/// ```rust\n/// generate_serialize_to_fields(quote { my_string }, StringType, &[], false)\n/// // Returns:\n/// // ([`my_string_as_bytes[0] as Field`, `my_string_as_bytes[1] as Field`, ...],\n/// // [`let my_string_as_bytes = my_string.as_bytes()`])\n/// ```\n///\n/// ## Nested Struct with Omitted Field and packing enabled\n/// - u128 has a `Packable` implementation hence it will be packed.\n///\n/// For a more complex struct:\n/// ```rust\n/// struct MyStruct {\n///     value: u128,\n///     value2: Field,\n/// }\n/// ```\n///\n/// Serializing while omitting `value2`:\n/// ```rust\n/// generate_serialize_to_fields(quote { self }, MyStruct, &[quote { self.value2 }], true)\n/// // Returns:\n/// // ([`value_packed[0]`], [`let value_packed = self.value.pack()`])\n/// ```\n///\n/// # Panics\n/// - If the type is unsupported for serialization.\n/// - If the provided `typ` contains invalid constants or incompatible structures.\npub comptime fn generate_serialize_to_fields(\n    name: Quoted,\n    typ: Type,\n    omit: [Quoted],\n    should_pack: bool,\n) -> ([Quoted], [Quoted]) {\n    let mut fields = &[];\n    let mut aux_vars = &[];\n\n    // Proceed if none of the omit rules omits this name\n    if !omit.any(|to_omit| to_omit == name) {\n        // If the type implements `Packable`, its length will be assigned to the `maybe_packed_len_typ` variable.\n        let maybe_packed_len_typ = std::meta::typ::fresh_type_variable();\n        let packable_constraint =\n            quote { crate::traits::Packable<$maybe_packed_len_typ> }.as_trait_constraint();\n\n        if (should_pack & typ.implements(packable_constraint)) {\n            // Packing is enabled and the given type implements the `Packable` trait so we call the `pack()`\n            // method, add the resulting field array to `aux_vars` and each field to `fields`.\n            let packed_len = maybe_packed_len_typ.as_constant().unwrap();\n\n            // We collapse the name to a one that gets tokenized as a single token (e.g. \"self.value\" -> \"self_value\").\n            let name_at_one_token = collapse_to_one_token(name);\n            let packed_struct_name = f\"{name_at_one_token}_aux_var\".quoted_contents();\n\n            // We add the individual fields to the fields array\n            let pack_method = get_trait_impl_method(\n                typ,\n                quote { crate::traits::Packable<$packed_len> },\n                quote { pack },\n            );\n            let packed_struct = quote { let $packed_struct_name = $pack_method($name) };\n            for i in 0..packed_len {\n                fields = fields.push_back(quote { $packed_struct_name[$i] });\n            }\n\n            // We add the new auxiliary variable to the aux_vars array\n            aux_vars = aux_vars.push_back(packed_struct);\n        } else if typ.is_field() {\n            // For field we just add the value to fields\n            fields = fields.push_back(name);\n        } else if typ.as_integer().is_some() | typ.is_bool() {\n            // For integer and bool we just cast to Field and add the value to fields\n            fields = fields.push_back(quote { $name as Field });\n        } else if typ.as_data_type().is_some() {\n            // For struct we pref\n            let nested_struct = typ.as_data_type().unwrap();\n            let params = nested_struct.0.fields(nested_struct.1);\n            let struct_flattened = params.map(|(param_name, param_type): (Quoted, Type)| {\n                let maybe_prefixed_name = if name == quote {} {\n                    // Triggered when the param name is of a value available in the current scope (e.g. a function\n                    // argument) --> then we don't prefix the name with anything.\n                    param_name\n                } else {\n                    // Triggered when we want to prefix the param name with the `name` from function input. This\n                    // can typically be `self` when implementing a method on a struct.\n                    quote { $name.$param_name }\n                };\n                generate_serialize_to_fields(\n                    quote {$maybe_prefixed_name},\n                    param_type,\n                    omit,\n                    should_pack,\n                )\n            });\n            let struct_flattened_fields = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (fields, _): (_, [Quoted])| acc.append(fields),\n            );\n            let struct_flattened_aux_vars = struct_flattened.fold(\n                &[],\n                |acc: [Quoted], (_, aux_vars): ([Quoted], _)| acc.append(aux_vars),\n            );\n            fields = fields.append(struct_flattened_fields);\n            aux_vars = aux_vars.append(struct_flattened_aux_vars);\n        } else if typ.as_array().is_some() {\n            // For array we recursively call `generate_serialize_to_fields(...)` for each element\n            let (element_type, array_len) = typ.as_array().unwrap();\n            let array_len = array_len.as_constant().unwrap();\n            for i in 0..array_len {\n                let (element_fields, element_aux_vars) = generate_serialize_to_fields(\n                    quote { $name[$i] },\n                    element_type,\n                    omit,\n                    should_pack,\n                );\n                fields = fields.append(element_fields);\n                aux_vars = aux_vars.append(element_aux_vars);\n            }\n        } else if typ.as_str().is_some() {\n            // For string we convert the value to bytes, we store the `as_bytes` in an auxiliary variables and\n            // then we add each byte to fields as a Field\n            let length_type = typ.as_str().unwrap();\n            let str_len = length_type.as_constant().unwrap();\n            let as_member = name.as_expr().unwrap().as_member_access();\n            let var_name = if as_member.is_some() {\n                as_member.unwrap().1\n            } else {\n                name\n            };\n            let as_bytes_name = f\"{var_name}_as_bytes\".quoted_contents();\n            let as_bytes = quote { let $as_bytes_name = $name.as_bytes() };\n            for i in 0..str_len {\n                fields = fields.push_back(quote { $as_bytes_name[$i] as Field });\n            }\n            aux_vars = aux_vars.push_back(as_bytes);\n        } else {\n            panic(\n                f\"Unsupported type for serialization of argument {name} and type {typ}\",\n            )\n        }\n    }\n    (fields, aux_vars)\n}\n\n/// From a quote that gets tokenized to a multiple tokens we collapse it to a single token by replacing all `.` with `_`.\n/// E.g. \"self.values[0]\" -> \"self_values_0_\"\ncomptime fn collapse_to_one_token(q: Quoted) -> Quoted {\n    let tokens = q.tokens();\n\n    let mut single_token = quote {};\n    for token in tokens {\n        let new_token = if ((token == quote {.}) | (token == quote {[}) | (token == quote {]})) {\n            quote {_}\n        } else {\n            token\n        };\n        single_token = f\"{single_token}{new_token}\".quoted_contents();\n    }\n    single_token\n}\n\npub(crate) comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, aux_vars) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let aux_vars_for_serialization = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let field_serializations = fields.join(quote {,});\n    let serialized_len = fields.len();\n    quote {\n        impl Serialize<$serialized_len> for $typ {\n            fn serialize(self) -> [Field; $serialized_len] {\n                $aux_vars_for_serialization\n                [ $field_serializations ]\n            }\n        }\n    }\n}\n\npub(crate) comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let (fields, _) = generate_serialize_to_fields(quote { self }, typ, &[], false);\n    let serialized_len = fields.len();\n    let (deserialized, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { serialized }, 0, false);\n    quote {\n        impl Deserialize<$serialized_len> for $typ {\n            fn deserialize(serialized: [Field; $serialized_len]) -> Self {\n                $deserialized\n            }\n        }\n    }\n}\n\n/// Generates `Packable` implementation for a given struct and returns the packed length.\n///\n/// Note: We are having this function separate from `derive_packable` because we use this in the note macros to get\n/// the packed length of a note as well as the `Packable` implementation. We need the length to be able to register\n/// the note in the global `NOTES` map. There the length is used to generate partial note helper functions.\npub comptime fn derive_packable_and_get_packed_len(s: TypeDefinition) -> (Quoted, u32) {\n    let packing_enabled = true;\n\n    let typ = s.as_type();\n    let (fields, aux_vars) =\n        generate_serialize_to_fields(quote { self }, typ, &[], packing_enabled);\n    let aux_vars_for_packing = if aux_vars.len() > 0 {\n        let joint = aux_vars.join(quote {;});\n        quote { $joint; }\n    } else {\n        quote {}\n    };\n\n    let (unpacked, _) =\n        generate_deserialize_from_fields(quote { self }, typ, quote { packed }, 0, packing_enabled);\n\n    let field_packings = fields.join(quote {,});\n    let packed_len = fields.len();\n    let packable_trait: TraitConstraint = quote { Packable<$packed_len> }.as_trait_constraint();\n    (\n        quote {\n        impl $packable_trait for $typ {\n            fn pack(self) -> [Field; $packed_len] {\n                $aux_vars_for_packing\n                [ $field_packings ]\n            }\n\n            fn unpack(packed: [Field; $packed_len]) -> Self {\n                $unpacked\n            }\n        }\n    },\n        packed_len,\n    )\n}\n\npub(crate) comptime fn derive_packable(s: TypeDefinition) -> Quoted {\n    let (packable_impl, _) = derive_packable_and_get_packed_len(s);\n    packable_impl\n}\n\n#[derive(Packable, Serialize, Deserialize, Eq)]\npub struct Smol {\n    a: Field,\n    b: Field,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct HasArray {\n    a: [Field; 2],\n    b: bool,\n}\n\n#[derive(Serialize, Deserialize, Eq)]\npub struct Fancier {\n    a: Smol,\n    b: [Field; 2],\n    c: [u8; 3],\n    d: str<16>,\n}\n\nfn main() {\n    assert(false);\n}\n\n#[test]\nfn smol_test() {\n    let smol = Smol { a: 1, b: 2 };\n    let serialized = smol.serialize();\n    assert(serialized == [1, 2], serialized);\n    let deserialized = Smol::deserialize(serialized);\n    assert(deserialized == smol);\n\n    // None of the struct members implements the `Packable` trait so the packed and serialized data should be the same\n    let packed = smol.pack();\n    assert_eq(packed, serialized, \"Packed does not match serialized\");\n}\n\n#[test]\nfn has_array_test() {\n    let has_array = HasArray { a: [1, 2], b: true };\n    let serialized = has_array.serialize();\n    assert(serialized == [1, 2, 1], serialized);\n    let deserialized = HasArray::deserialize(serialized);\n    assert(deserialized == has_array);\n}\n\n#[test]\nfn fancier_test() {\n    let fancier =\n        Fancier { a: Smol { a: 1, b: 2 }, b: [0, 1], c: [1, 2, 3], d: \"metaprogramming!\" };\n    let serialized = fancier.serialize();\n    assert(\n        serialized\n            == [\n                1, 2, 0, 1, 1, 2, 3, 0x6d, 0x65, 0x74, 0x61, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x61,\n                0x6d, 0x6d, 0x69, 0x6e, 0x67, 0x21,\n            ],\n        serialized,\n    );\n    let deserialized = Fancier::deserialize(serialized);\n    assert(deserialized == fancier);\n}\n"
     },
-    "295": {
+    "296": {
       "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"
     },
-    "334": {
+    "335": {
       "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"
     },
-    "350": {
+    "351": {
       "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"
     },
-    "353": {
+    "354": {
       "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"
     },
-    "359": {
+    "360": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/sha256/v0.1.2/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nuse constants::{\n    BLOCK_BYTE_PTR, BLOCK_SIZE, HASH, INITIAL_STATE, INT_BLOCK, INT_BLOCK_SIZE, INT_SIZE,\n    INT_SIZE_PTR, MSG_BLOCK, MSG_SIZE_PTR, STATE, TWO_POW_16, TWO_POW_24, TWO_POW_32, TWO_POW_8,\n};\n\nmod constants;\nmod tests;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    assert(message_size <= N);\n\n    if std::runtime::is_unconstrained() {\n        // Safety: SHA256 is running as an unconstrained function.\n        unsafe {\n            __sha256_var(msg, message_size)\n        }\n    } else {\n        let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n        // Intermediate hash, starting with the canonical initial value\n        let mut h: STATE = INITIAL_STATE;\n        // Pointer into msg_block on a 64 byte scale\n        let mut msg_byte_ptr = 0;\n        let num_blocks = N / BLOCK_SIZE;\n        for i in 0..num_blocks {\n            let msg_start = BLOCK_SIZE * i;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n\n            // If the block is filled, compress it.\n            // An un-filled block is handled after this loop.\n            if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n                h = sha256_compression(msg_block, h);\n            }\n        }\n\n        let modulo = N % BLOCK_SIZE;\n        // Handle setup of the final msg block.\n        // This case is only hit if the msg is less than the block size,\n        // or our message cannot be evenly split into blocks.\n        if modulo != 0 {\n            let msg_start = BLOCK_SIZE * num_blocks;\n            let (new_msg_block, new_msg_byte_ptr) =\n                unsafe { build_msg_block(msg, message_size, msg_start) };\n\n            if msg_start < message_size {\n                msg_block = new_msg_block;\n            }\n\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        }\n\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        if msg_byte_ptr == BLOCK_SIZE {\n            msg_byte_ptr = 0;\n        }\n\n        // Pad the rest such that we have a [u32; 2] block at the end representing the length\n        // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n        // Here we rely on the fact that everything beyond the available input is set to 0.\n        let index = msg_byte_ptr / INT_SIZE;\n        msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n        msg_byte_ptr = msg_byte_ptr + 1;\n        let last_block = msg_block;\n\n        // If we don't have room to write the size, compress the block and reset it.\n        if msg_byte_ptr > MSG_SIZE_PTR {\n            h = sha256_compression(msg_block, h);\n            // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n            msg_byte_ptr = 0;\n        }\n\n        msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n\n        hash_final_block(msg_block, h)\n    }\n}\n\n// Variable size SHA-256 hash\nunconstrained fn __sha256_var<let N: u32>(msg: [u8; N], message_size: u32) -> HASH {\n    let num_full_blocks = message_size / BLOCK_SIZE;\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = INITIAL_STATE;\n    // Pointer into msg_block on a 64 byte scale\n    for i in 0..num_full_blocks {\n        let (msg_block, _) = build_msg_block(msg, message_size, BLOCK_SIZE * i);\n        h = sha256_compression(msg_block, h);\n    }\n\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    let modulo = message_size % BLOCK_SIZE;\n    let (mut msg_block, mut msg_byte_ptr): (INT_BLOCK, u32) = if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_full_blocks;\n        let (new_msg_block, new_msg_byte_ptr) = build_msg_block(msg, message_size, msg_start);\n\n        (new_msg_block, new_msg_byte_ptr)\n    } else {\n        // If we had modulo == 0 then it means the last block was full,\n        // and we can reset the pointer to zero to overwrite it.\n        ([0; INT_BLOCK_SIZE], 0)\n    };\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    let index = msg_byte_ptr / INT_SIZE;\n    msg_block[index] = set_item_byte_then_zeros(msg_block[index], msg_byte_ptr, 1 << 7);\n\n    // If we don't have room to write the size, compress the block and reset it.\n    let (h, mut msg_byte_ptr): (STATE, u32) = if msg_byte_ptr >= MSG_SIZE_PTR {\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        (sha256_compression(msg_block, h), 0)\n    } else {\n        (h, msg_byte_ptr + 1)\n    };\n    msg_block = attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size);\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if message_size < msg_start {\n        // This function is sometimes called with `msg_start` past the end of the message.\n        // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n        0\n    } else if message_size < msg_start + BLOCK_SIZE {\n        message_size - msg_start\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\n#[inline_always]\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\n#[inline_always]\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\n#[inline_always]\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\n#[inline_always]\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        // Brillig wouldn't shift 0<<4 without overflow.\n        if shifts >= 4 {\n            0\n        } else {\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod equivalence_test {\n\n    #[test]\n    fn test_implementations_agree(msg: [u8; 100], message_size: u64) {\n        let message_size = message_size % 100;\n        let unconstrained_sha = unsafe { super::__sha256_var(msg, message_size as u32) };\n        let sha = super::sha256_var(msg, message_size);\n        assert_eq(sha, unconstrained_sha);\n    }\n}\n"
     },
@@ -3827,7 +3829,7 @@
     },
     "57": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/capsules/mod.nr",
-      "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push<let N: u32>(self, value: T)\n    where\n        T: Serialize<N>,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get<let N: u32>(self, index: u32) -> T\n    where\n        T: Deserialize<N>,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n    use protocol_types::address::AztecAddress;\n\n    global SLOT: Field = 1230;\n\n    unconstrained fn setup() -> AztecAddress {\n        TestEnvironment::new().unkonstrained().this_address()\n    }\n\n    #[test]\n    unconstrained fn empty_array() {\n        let contract_address = setup();\n\n        let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n        assert_eq(array.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        let _: Field = array.get(0);\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        assert_eq(array.len(), 1);\n        assert_eq(array.get(0), 5);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        let _ = array.get(1);\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(5);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        assert_eq(array.len(), 3);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 8);\n        assert_eq(array.get(2), 9);\n\n        array.remove(1);\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 9);\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        array.remove(1);\n        array.remove(1);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n}\n"
+      "source": "use crate::oracle::capsules;\nuse protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// A dynamically sized array backed by PXE's non-volatile database (called capsules). Values are persisted until\n/// deleted, so they can be e.g. stored during simulation of a transaction and later retrieved during witness\n/// generation. All values are scoped per contract address, so external contracts cannot access them.\npub struct CapsuleArray<T> {\n    contract_address: AztecAddress,\n    /// The base slot is where the array length is stored in capsules. Array elements are stored in consecutive slots\n    /// after the base slot. For example, with base slot 5: the length is at slot 5, the first element (index 0) is at\n    /// slot 6, the second element (index 1) is at slot 7, and so on.\n    base_slot: Field,\n}\n\nimpl<T> CapsuleArray<T> {\n    /// Returns a CapsuleArray connected to a contract's capsules at a base slot. Array elements are stored in\n    /// contiguous slots following the base slot, so there should be sufficient space between array base slots to\n    /// accommodate elements. A reasonable strategy is to make the base slot a hash of a unique value.\n    pub unconstrained fn at(contract_address: AztecAddress, base_slot: Field) -> Self {\n        Self { contract_address, base_slot }\n    }\n\n    /// Returns the number of elements stored in the array.\n    pub unconstrained fn len(self) -> u32 {\n        // An uninitialized array defaults to a length of 0.\n        capsules::load(self.contract_address, self.base_slot).unwrap_or(0) as u32\n    }\n\n    /// Stores a value at the end of the array.\n    pub unconstrained fn push<let N: u32>(self, value: T)\n    where\n        T: Serialize<N>,\n    {\n        let current_length = self.len();\n\n        // The slot corresponding to the index `current_length` is the first slot immediately after the end of the\n        // array, which is where we want to place the new value.\n        capsules::store(self.contract_address, self.slot_at(current_length), value);\n\n        // Then we simply update the length.\n        let new_length = current_length + 1;\n        capsules::store(self.contract_address, self.base_slot, new_length);\n    }\n\n    /// Retrieves the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn get<let N: u32>(self, index: u32) -> T\n    where\n        T: Deserialize<N>,\n    {\n        assert(index < self.len(), \"Attempted to read past the length of a CapsuleArray\");\n\n        capsules::load(self.contract_address, self.slot_at(index)).unwrap()\n    }\n\n    /// Deletes the value stored in the array at `index`. Throws if the index is out of bounds.\n    pub unconstrained fn remove(self, index: u32) {\n        let current_length = self.len();\n        assert(index < current_length, \"Attempted to delete past the length of a CapsuleArray\");\n\n        // In order to be able to remove elements at arbitrary indices, we need to shift the entire contents of the\n        // array past the removed element one slot backward so that we don't end up with a gap and preserve the\n        // contiguous slots. We can skip this when deleting the last element however.\n        if index != current_length - 1 {\n            // The source and destination regions overlap, but `copy` supports this.\n            capsules::copy(\n                self.contract_address,\n                self.slot_at(index + 1),\n                self.slot_at(index),\n                current_length - index - 1,\n            );\n        }\n\n        // We can now delete the last element (which has either been copied to the slot immediately before it, or was\n        // the element we meant to delete in the first place) and update the length.\n        capsules::delete(self.contract_address, self.slot_at(current_length - 1));\n        capsules::store(self.contract_address, self.base_slot, current_length - 1);\n    }\n\n    unconstrained fn slot_at(self, index: u32) -> Field {\n        // Elements are stored immediately after the base slot, so we add 1 to it to compute the slot for the first\n        // element.\n        self.base_slot + 1 + index as Field\n    }\n}\n\nmod test {\n    use crate::test::helpers::test_environment::TestEnvironment;\n    use super::CapsuleArray;\n    use protocol_types::address::AztecAddress;\n\n    global SLOT: Field = 1230;\n\n    unconstrained fn setup() -> AztecAddress {\n        TestEnvironment::new().utility().this_address()\n    }\n\n    #[test]\n    unconstrained fn empty_array() {\n        let contract_address = setup();\n\n        let array: CapsuleArray<Field> = CapsuleArray::at(contract_address, SLOT);\n        assert_eq(array.len(), 0);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn empty_array_read() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        let _: Field = array.get(0);\n    }\n\n    #[test]\n    unconstrained fn array_push() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        assert_eq(array.len(), 1);\n        assert_eq(array.get(0), 5);\n    }\n\n    #[test(should_fail_with = \"Attempted to read past the length of a CapsuleArray\")]\n    unconstrained fn read_past_len() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n        array.push(5);\n\n        let _ = array.get(1);\n    }\n\n    #[test]\n    unconstrained fn array_remove_last() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(5);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n\n    #[test]\n    unconstrained fn array_remove_some() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        assert_eq(array.len(), 3);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 8);\n        assert_eq(array.get(2), 9);\n\n        array.remove(1);\n\n        assert_eq(array.len(), 2);\n        assert_eq(array.get(0), 7);\n        assert_eq(array.get(1), 9);\n    }\n\n    #[test]\n    unconstrained fn array_remove_all() {\n        let contract_address = setup();\n\n        let array = CapsuleArray::at(contract_address, SLOT);\n\n        array.push(7);\n        array.push(8);\n        array.push(9);\n\n        array.remove(1);\n        array.remove(1);\n        array.remove(0);\n\n        assert_eq(array.len(), 0);\n    }\n}\n"
     },
     "58": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/call_interfaces.nr",
@@ -3846,8 +3848,8 @@
       "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"
     },
     "68": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/unconstrained_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 UnconstrainedContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UnconstrainedContext {\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 an UnconstrainedContext 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"
+      "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"
     },
     "70": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr",