@aztec/protocol-contracts 0.82.2-alpha-testnet.4 → 0.82.3

package/artifacts/MultiCallEntrypoint.json

@@ -110,85 +110,11 @@
         }
       },
       "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
-      "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiT0xv/mSe7DRJ/JkrYbTwBCAyo04AwG6AINEGiARANOaECJBig0AG2yRpus0SZrtMmENpnQJhPaZEKbTGiTCW0yoU0mtMkENXlL6WGiM7W3e8PpltAcCs/8HO1P9xnj0Nh2iTa3oG8Byq+xlFzJfO1sr6gKLiqVIAn0Ag==",
+      "debug_symbols": "tZbRCoMgGIXfxWsv0qV/26uMMawsBLGwGozo3acjttiuz0105NfPCz84K2ttvfR3F7phYpfryvzQmNkNIaV146yOznvX34/LrMgfofR7wzSakPM0mzizizgJUpzZ0OZ/KVU6pHPepiSqjf/Nk9yHiT6TJW03ngCEBlRowBkM0AUaINAAiQac0IASDVBoANpkjTZZo03WaJMJbTKhTSa0yYQ2mdAmE9pkQptMaJMJavKW0sNEZ2pv94bTLaE5FJ75Odqf7jPGobHtEm1uQd8ClF9jKbmS+drZXlEVXFQqQRLoBQ==",
       "brillig_names": [
         "process_log"
       ]
     },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "parameters": [],
-        "return_type": null,
-        "error_types": {
-          "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"
-              }
-            ]
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "6753155520859132764": {
-            "error_kind": "string",
-            "string": "Failed to deliver note"
-          },
-          "8830323656616886390": {
-            "error_kind": "string",
-            "string": "Got a public log emitted by a different contract"
-          },
-          "13649294680379557736": {
-            "error_kind": "string",
-            "string": "extend_from_bounded_vec out of bounds"
-          },
-          "14657895983200220173": {
-            "error_kind": "string",
-            "string": "Attempted to read past the length of a CapsuleArray"
-          },
-          "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/+1dXYhcyXWunu6eme6Z1rT+tV7J6/WPdjde2/03f5Jszb9GWv2sd9eGQCD0dLcUO+uVWWkNBkMmJBDyYkhiHPKSvDgEB4c4TmJsMAkO+SEQ/BQ2GILJQ1jIQyA4G5I8xLGudE/3N1+fW3175tRMa3cKhum+deo7p06dc+pU3bq3M65XMvH/nNtDEZBnCo/+x//cGNRnH/wtxd8reyvVAvG1xF+oNBYLSv8M5a8XYsxMGPyK4AfSf2Uixrm63cPHvgjfyQd/U/D5mOvZR6j+y/iF7P9xT5/Fdla3XbfY8G20BXttO0i/aoK/Hga/IfgbYfDrgn8lDH5F8DfD4FcjX4n85MuTj/CmH/wdibHvdO6vvHq39Ys33/jcVud1sTyRAi0Rr2ddf4lQj/VQV+++dv/1Zuv+crv9eufePUYYU5BdAmoRUH+h+ZnXrraT5BkS7dOd1+995u5rjJZLiSbxIA/00d9S/L2ypzLfjTfjQfBr3Xg+EQR/bk7wJ8PopzvfFcLIf1vwi2Hwq4I/FQa/LfjTYfAbgl8Kg9+1/yNB8Ge79j8TRv6ufZbD4HcE/2gY/FnBPxYEf74bH46HkX9e8E+Ekb9WivFOul6ROUN4n4LrdnN6ta3NzDwLIv8iyWqdY2SIn8jD+pF5X3R3WpG1rNRxDDit8Dmt8NGwjhpinTDEmjDEKoxoH6cMsUqGWGVDrOOGWOOGWJa6t/ShyRHFKhpiWdqEpe4t7WvaEMvSty1tYsYQyzJGHzPEGtX5UdbZYXOr3j7nmTD4dZ8usE/CX3KlI0CfSfgvWFwnvIqEZdy3qq9vKL9vnFEHe7UZwSoodSHG9JSn38w/iV7Ll4X+CQ8+0s+4fht+gnTxnjC6qPnG7QngKfyjeUNidLuz9cad63fvOCpZ0oPo7SzRyR7tmOvX95kELEffz9K1LOBhieSWGH7vi6+1bt6937nnBpSwmxrzW4J/Mgx+Wwu+hvgVzVEN8RtacLfDn2tJsEZHzdDYh3G86mLayUD4F12/U4aYDN5D8rB+eFPgSUXWslLHPvSkwudJhY+GddIQa9wQ65Qh1lFDrLIh1rQhVmlE+3jcEGtU7atoiHXCEOu0IZalfVnq64whlqV9WfpQwRDL0iYs46okwgWlzjBX6OYpnEBHRerOAW+eo98L9HIoJaNg8VEB7FPU169M9nCZjuXBvOkc4LOeMN8QPZ6FeutDY6gPY/zuwvKc26lT7tN7E3Ql9dp/weI64VV0/XoPkR9qfUP52V/QLlEHSVjnhsQqKHUhxvSsp9/Iv+SRVevHk6QTLR5p+bfQv9cjF9LPKLylrejwKagLscmg6RB9UfjvZpNB9HaG6OSg1pjrt8FzCViOvp+ha0mbDL71ZBp/FjmjUlawZMMk8KbQbW0+y5jhNxqB43xbiwnOhZ1HDPVTZ380lL27Z/O+MLJ3dfN0mLHt7pm9Pwz+guB/IAx+96DOB4PgN7rj+6Ew49s9CHQ+CP58Vz/PBMGvd/XzrOsVI910D3k9F0Y33UNSPxMEf7Yblz9srptKF/t5kN0QvzuuHwljN9249lHAN4wLLcH/WBj87gHNShj8blyouj3bTp0vCHYtyNjOdWN+PYzt1AS/EUb33bgzu3fd9wkv2HNBdDPbzTXnw+imKfgLYfC7MXnRXve1aG/vxzHWDOhe+sE3iXNB+lhvyrrmgusvUncRePP+0yWgH3b/Sfo07P4Trq1QNsTMu946FPWahXqk///4fzQuP4k/Rwf1ZGw+ARg8NkuEL98reyqNqvR32fUXqVsB3jw2q0A/7NgsxZ+HHZvLUIeyISaODer1MtQj/VSmJ8vXJnsyM79PuH75PkHfn1X4lYif1EdFxngZrhvu/1YyxE/6hteQf9GFtLneXuAyycP6EVuL9nPkQOurd5vt1ebn773xameMVInDhPAzBCc0SItlBkRCem7Pw/4epR0XUWWeZJb7+VFoOBl/LiXwiUrB9ffZcpmc1mSEf9H1u1oIk7lM8rB+ODwtKbKWlTrcumQz9JnmIdYh1kFhSdqgTU8+f7ns4aNNlSXAk7rnqS6ryCd1OU/dBU/dRaVfWkoo29pS93EFM4qrv5zpXU/SzRJck61/LT1LmmuSsNYIC9svE9bKAKwNwsL2nA6tDsBaJyxsv0pYax6s6PMH3E4sbL9GWOsDsCqEhe3XCWtjANYCYWH7DcK6MgDr/YSF7a8Q1uYArI8RFrbfJKyrA7DmCQvbXyWsawOwniYsbH+NsF4YgPVRwsL2LxDW9QFYZwkL20vbkoIlcUtyphtw/SByJuFfJFmN5enmTDdcv15RP5wz3VRkLSt1HGtuKnxuKnw0rFVDrDVDrHVDrA1DrCuGWJuGWFcNsa4ZYnGs8c2L0WfZavXNi9IO7Q3pskCjzYWIkTTvZp0+n15P0R+8xrq5nsAvSb4loJF1rm+en1HascxLHj6DZBY6LTflozQYgzmPxNyU813MTZep7qLSL85NcVy13FT0hrlpnvrzq/GHAslvPFdU8JnCJF0dwD5EJ0P8nDvYfQhtu5R1sRKEd6OaVhcrpIvlQLrwxQttT0botdx/WaHHbb87nfvX795Z+eIrzTsTQMquj+KUiO4yfV9KEGuJ6Fbou7gty4FYWFgO3lZk+qUB9FodY4gprhPtUvy9srfSvZt9JQx+99SktrTDPgl/ccs1RVdp3UZ4FQkrlNtofUP5efrD9DHNEnhjSKyCUhdiTNc9/Ub+JY+s5QRZo8JT6JNx56Np9vcyO7HZn1AP2SB6qM+ltUe5VnT9cS6EPWZJHtYPLxNziqxlpY5PkuUUPjmFj4ZVMMQ6b4hVNsSaNsQaH9E+Wo6jZR9nRrSPU4ZYpwyxzhhiHTXEOm2IVTLEsrQJS3+09CFLm7DU13FDrElDLEvdTxhiWer+hCGWpb4sY2HREMtSX6MaCy31ZRlz3g05k6VNWM7blrp/zhDL0u4tdV8zxLLUvWUfLeOEZQ5gqa8jhlj8dpu063q5flGhX1Po5RYP3iaRtrKHgrdCDPcsaj494a0Z4b+bJ4Ll+yzR8RPBqPsLCViOvs/StazTnwj2ndpPO774UxMo77hCj3h8ev2JeOAjPf5BrMyyIlMW8OXpA97Lc8Az7F5yvZYhfs7tHB9H/Iskq7HtdvfbtKNG2p6t6G5TkbWs1PFTxdoxpE2Fj4ZVMMSaMsQ6ZYh1xhDrqCHWaUOskiGWpU2UDbHGDbEsbcJSX8cNsSz1NWGIZamv84ZYlrY6bYj1bhjHE4ZYlvqynIeKhliW+hrVechSX5bx3tK+LGOOpT9a2oRlzmSp++cMsSzt3lL3NUMsS91b9tEyToxq/nXEEEv2j7THUtaIj7aGveLhg+2vpMDS1sNCrz3G4tun0h5jkb0HPB4eYp9KGw/tUZjd7FOJ3qpEx/tUOMZXE7Acfa/StaR9Kj5z9eVY+aLfNcJYir9X9li0Y8tsoxmQUfp7ZbtHczmhD78B+11/OLkTE+1MxhOPvPKjg5p8/D2v0I5RndB+FWT7o1i2NGfaAo1DK0P8RC8uoe/7daZNGyeUcYz0E2jPbyvj+uNZVuEp8spY+mKv+DO+6QLpN6CP7P8Yj/J07WuxUsoKJj/GnDb+R3Pd747t7Bv7gfZfcPmab14ROuGD503F7yN5vj62sw3HCWwbfX4a6pH+C5M9zG/EmNojwywj+yLGoqisbe+kF1lk355pOI4J/Z9ArPgmxbHLSp+f9sgsmHjPAx/9eD5Bhm/TfBDIz9T5QHjt9+Py/LwB9j/QufzUcVj4FxWdhIjD6yn1OipxWOTV4jCfvQ8Vh/8uUBz+PsUo7A+/1kAbt3UFt6y0Zx1iu73Ge01mn9/tlg9iYc6I45oUO/HeN45HDq6jzXHsFPp/hPj9p55cD+e2N8cGy5pRZM0T/c/C3PZDshu8z87PZeD4XKS6ywrfDNE6kBNpeD4SOccT6C8m9OtflHvZGUUX2rheTJAhl9Cv5xNk+NddjOtbY4NlxXHltYXQX4Jx/TcaV5TdN66XqA7HVXSk5UE85rhu0tZS7JPY/uAfUW2lfixzVF+VFXZt2KpkCB/lWVP0EzhHqmtzOs97g+b0NdAh0uNnaY/XsrFhaM+28ZkOrOP5fi/P+4XE8uUhOKZR3PkfWg+GmLe1GBFi3RkVidNaXsXrjGHzKmyfJq8Km0fPzqeNefxMbajnkX22rOlViwEbpHOsex98HmTnyEfDOj2iWEcNsaYMsU4ZYlnqq2SIVTbEOm6INT6ifSyMqFwzhliW/mg5jtOGWJY+NGmIZTmOlrZ6zBDL0r5OGGLlDbEs7X5UY45lH48YYj1jiHXSEMtSX5a5iaV9jWpeaGn3o5rLFQ2xzhhivRtyuVG1e8vc5HBOGw5rVHO5UY2FlrmcZSy0HEdLfY1q/vURQ6xRzb8mDLEsfdvShyz1ZTkPWfrQqOreMn5Z7suN6t6QpX1Z5r6jmmOO6txRN8Q6Se3wntQKYMg9K7yXannfV/CvBcIXXWk/1YF9Ev58D0rqtf+CxXXCq+j69R7i/prWN58d4DMXqIMkrKtDYhWUuhBjuunpN/IveWTV+rFhqJMxQ6wcYaW9ryr02rM5mp2805/NEb19mug2tnt6YN9I+2zOp+la1unP5mjnEfgM1rDnEbQzYvt17uGd1p80Z9fCnJuoLaadZ/i8eOiza5pefT/zmPYd4fzL93s5+1QzxCoZYk0aYo0bYs0YYhUMscqGWKcNsU4YYhUNsSzH0VJflrY6bYhlaatHDbFGNU5Y+qOl7kfVVs8bYlnahKWtWurrlCGWZYy2zAGOGWJZzh2WPjSq9vVuiF8h5qGDO89eT/3TrcL/cT/P/iH4jHXI5yDukView7G8f2B5v8Xy/Oy4Idao3s+z7OOongUZ1eclzhtijerZLEv7soyFlnIdntc7ON3XDLEs7cvyXr1lHy11P2GI9W44H3QYJw5O95Z9tHyGxjKfGFXdW56dOfSh4bDmDLEOfejgdG+5drdcI8v5s0Hv1vlWbidP2T9JerfOCtQj/X/me5h/ntvJ+wLwFizZ2wpzT71WyRA/5/S9LeFfJFlt5entbWnv/UH98N7WsiJrWal7Ej5jHfJZVvhoWCVDrElDrBlDrIIh1jFDrKOGWCdGVK5pQ6xxQ6ziiMp12hDL0u4t5bLU/RlDLMtxtNT9hCGWZR+PGGI9Y4h10hDLUl9lQ6xR9W3LuUPyCe0di5epDt+HtpbAD+miInnpKtRb5oGh3/OXof5in7FPfA53BegzCf8Fi+v4/fYrgXTn6xvKz/aD71tEHSRhrQ2JFfh3BrpjuurpN/IveWTV+rFMOtH4aGsUod/wyIX02tlyaRv291B7zz1o443nK4T/bp57EL09RXT8mySo+/UELEffn6JrWcDDov0+MZ/fv0B9SBrfstJe6NKs7cPEgXo9bVwS/vu1tl9JqVfR3aoia1mp47W95p+rCh8Nq2SINWmINWOIVTDEOmaIddQQ68SIyjVtiDVuiHXEEOsZQ6yThliW+iobYln642lDLEu7t4yFluM4YYhlOY6W8ctSX6cMsYqGWJb6svQhy3zCUl9nDLEO4+rBxVVL3T9niGVp95a6rxliWereso+WceK4Idao5qsfMcSSfDXwPmntcJ901+Vwn9TTb+S/133SvegkS1hZBcu355p2bGdc/3hK28A+1t1zXXbJekL+u9lzle81olvb7umBx241AcvR9xpdyzr/niviXUqQU/jyNbaVS8Q3KoPOcn01r/NMOsvFv50q9D+As1y/k9/ZR2z/RPxZ7ChHMi/F3yt7KvWmttfsSCf4+3S8z3oJ6Fe3e3RcsvQd+xTZ5Vfg9+qYjuVBW+DfzhPMpHHBcUP638/3ZPn2pI6Zcbp9yT0IoRddjgMd0rAMQv91kIF/V1docgn9yiVg/gXY2zfyOqZTMLV+XaR+sQwXSAah/yb0S34bMev6x49tkK9F35+FzxddMlZGwbqUAiujfOcx535Hfx+Pvyfphsdc6L/jGfOMIgP+niWPT5ZkYBr+7Uqh+Z4iQzRfyDOErbuf/+Jq8/P33ni146jk4DOGB/nOw8dDkFFwkoqIHHVPzNrnCtwOvz+ryBB1WcJPu/Nq534nodPcybEEZmNOLxzHpF1Uwsb7R3kD8nNOz6eFf9H1236IfDpH8iTN4TxfYduyUid90uZY9ueMIkNGkaHsBseDTMr+TLvefZ179+++nmRzbCtsWzj3sjzc3hGWFiujEjnaj+PP+5WHMdaY08diY/vRf/GXZcJair9X9lR6vzUq+X/e6fPBMtQj/ZsQW79L8X3Z9etLeycdy4D03O+oaOcUVtxg3lpOE3Yvov+3XPMJfVuFeqT/kUe/2lrVp981hR77LfKIfrV1b1r9rm0/+j/q+n3rAPWL/rVGdSg7xyFN98uKXFocWk6BdUnBwnzpQfLwmS90Xr95934HQxZ319HnAl3jtCJH3y8kiDpFdBfpO2+z8dSyRN8/rsinFZEDy5SHV1IRExRd/QeY4PfIBLUpB2WQMMbLe2yLy3sxLzwqx+Y17KNj2F7oND58xHZTaZehOpRh0yMDtt+fV103uqFHXn2ctCS/CvVI/xNP6NFeRb2s9J9lQPqrRBMVTffXqA7bsW0M+4psbH/Vw+fKHvlcUfhkE7CllBRcjFWoG1vbqTQyxE/kxWvIv+hC2nJvmeKzo6jwMuUFRdayUrcIn7EO+byg8NGwVg2xfPGK/WfYuKjZt+8nDEbV5gIdq/banKbXYW3uKfi8VzsJgTXj+sebY5Wmm2sePtiefzYD27HNBfrJgNm0Nif8iy6oD1R946fpVXR3XZG1rNSxnVxX+FxX+DxOWNX4s9ivFk936yfYXuhKSrtMwn/hw9d2Owdco/4MOwdovr3Xn7HR+Azr97vlg1hy+5B9xIIP2tvzbiefDUWGaI2zPt5rE/3diGkwL8e2ssWWJ/r/nuhhbsaYWs6KMmL7HFy/qvSD+d2IeUgsvgltDGNfBR9HcMQr8FqpXaI+Yykp/WbfvwV17EcvQh3b/iehDseLC6/bURfR0uwvU9y+1WzkBaq7ofRD6m4q/dDi1VWqQ9+/QXUYf25SHerjHHxGHlHJuv6xk32HNHmzfEe/eF7hnSf6e+QXYXKCWtM3vxQUXVnyThMfkb8vHykqdbk9yNpZaHUWtxqNufnG7Gy9NT9s7sBxEem1bdSw8a+2IL6b3e7h3wC9RiUHddepLg91ImMUFrKFnfLfCCR/Gv1rMQDpr0AfhhnLY64/DnFutFs///V98fN6++D8vN4eZT+vdbZac83m7XrrdqXVvN2x9PN1hT6snz868vVQhu0e/uPj5/WmhZ/z0Zm9rPf4PoxFzDjce+2W4HuvH4bPHP+G3bsaM8Ty7YNxDjnsPpj285gHuA+W2uYO98H2B0vbu+J8Zljb1n4C9eByjvR7r8K/6IL6QNU3fppeec8A25aVOrYTLR+5ofB5nLB47xVth+13WD/B9kl5qNRr/4UPX/P5I9971nxot3OAL+8IsSea1u93ywexeO/1hiEftLe0e69/S3uvkjen3XsV+m/B3uvfe/ZeUUZsn3bvVeh/QGtP3GcMvfcqvALvvXZ4fxWLtr/Kvp92f5Vt/yWow/HiEmrv9TrVafurUndL6YcWr3jv1be/ivHnFtWhPnjvVYtzOHa893qY63pL8Fx3Fj5jHfJJm59eMcTynbdK2rtDPr7zVtpaLc2aftRsLvSa/oWUen03rK94TT/s+kq7r3a4vuq3ucP11e6xfOsrtt9h/UTLTUKvr3xzAK+vhp0DNN/2zQG77c+wfr9bPqO8vjo30WsT/e12ffU5WF+9L/48Q+1ZRpzvcX21ofSDz7h/KOYxCmdbwvwUsu36iv0o1PpKdDHs+mpD6Ydv/15be/nyGv4JZi1n1eIPr7186ystzuE6gNdXG0q/+Hteod2kOqG9AD74WY8P+p6XWUvoE8YDpP9ggiyXY/6RCRwp6JhjCmZU+BHVMHlN7xG/60oftbkhT/Rr0Mfvkq3jPWJ8nXhUcttB+lONRDha6MnB9pcHvjwv+datrCek950f860/tdezow/wY7Rh1lM9G8Ax5nlP80ehfzGlDYheD8IG8Dww24AWs7Rzxz6bwbHhOOt71kHjjXbBNhBmH8dvA9o8wTbwcyltQPR6EDaAemUb0PYFkT6NDWhzdBob0M6941zA500Ee9zp85Hg8Xx0B8ZIXqUj8uFPsrD9rinYOL/64llG6UeJ6rAt/vQh59d3YW7/Y8p9A91b6L66TvLIpNh4y+2UWejvKX6RoTaoL9/c86JCf0vRoZYXvkh12p78DNFGn3mtIjlzTsGOPvNaRei/ROOF+XXotcpL1IcXoQ+sx6jw+k7ofxvs75cot9TWIJo+OXfX1iAzitwyDqK/V1wQ/XXt/VOup4OsIusrbqeOhP7XUs4DeH8uKrntIP1paPPAy65XeB54BeqyCj375KcUehwb0VmZ6Nk/8TtifRKu8TwgOhx3+hjhPgbS/6ZnHsB89WWSHfOAF6ku7XrxJZB5f2L4bIX3ArD4nmXR9gJ4D+FlqOM9BLSDYfcQRBfD7iFYxCE+zzsqfivjEBX2W/TRrELPfjvIz2V/sOz6x9L3rM9LVJfGZ6KySfzQXmRs0Gd8MUNbP3AOjG1xD5Rzrj+DOe/txyTn+s6QOZe2D88yIP3jknN9/x2Qc/0z2N9f7zLn4vMo77Sc6x8Oc66Rz7n+aZc5F+4pWORcbz+GORefu3pccy5fHDrMuexyrjQ+E5W0OdfbgXIuOdfL7yz4X5jzFmM7DHyPt87xLSnnSopv/+fJuTR9+XIuLUfDfnPOheN2i+rSnku9TjJgvuIUes65hH6cxgt9PHTO9Unqwy3oA+sxKpxzCf3TcR8i+ytM7tSZdq9Z0ye/fyFtHJRxEP29HEZ/dY5JaO8o68tup46E/misl0E5F56TiEpuO0h/DjR2a3E2aR7G74iFeQLnXBgztTESPF67noUx4pwLcyeeP/A+LZ8tv6bw1eYknD/2J4Y3bvN5GCzaeRjOndAP+T0wafOxYd8Dg8+AD5NzWcQhfjZ9VPwW1x/st+ij2nqF/XaQn3POhWPJ9o0+w2usND4TFc650F66c6jr+YwvZqTNuW4A7jo994TvUJX3KfjOC2Wov5o8QoOfN0EGjZ7v2Qr9ihLDwp4HqWyJzLt99+6GMjdmqA3qzffab4t374Y9O9HTl3Z2Qnt3HJ+duJEyl7gE/YlKbjtIf1paTMJx45iU9t0KrCek197lp8WdTarDn0jjMxfamQaR4ZIiQwau+c4qSNvIl9+KO6fFDI4n2vu6OT6gPNq7ldmPxhPok85H/rwnngTyj6bPP7BfSf7R8sQTzfbwnfXD2h7HE+0MZODnrbrxRDuTuanIw2cyP5synuzPmUw9nuznmUyOGb5nTjGe8Jlo9Nk0ZznTxhM8+/QmxROkW0vBE98Jtbb96L/YK9qO4fi2OSYl7R0lxaQvefxbi4u+fEHLL7DfvHekvVsxsL62fPpaT6GvX0np3xnoT1Ry20H60xr2rKU2pr6zloPGVHSm3XPnXAJ9iHOCjMIH/Yl9eJ3aRyXy4a/HHQip9/mFSkV4ypiLHXHJQT3S/1ZsO0Xoh/zfyzvvbs83q7frzdvN2Wa73Wg1ea8yKjLGU+6RHX8Z7Fj4O2onfpl39vqsDPHzdsK/SLIay9N95jRP8rB+RJfTrvebOa/ebbbjX4MbI1Vil1idCMfdRrVgXZauZej7GLUTN9JMleXMKBiaCvixoozCP0vfURdOuTam0GdSYMnnrEeWJIwMYZQ8GNFQW7tua2tuqxG9srLamKs3Ku1BrmvNvzHbnG8156vVxUa106jO7jf/zlZjcX5rsTVbaVcWq4v1/eY/31x4wH2x0WzMVVqV+bn95l9bWJhbrG1VGvPt1u12Y9/7v9Wea1UW69V2szn/oPsL+97/drtTbVTnFxc6jUZ7cf/tb2HxgeHd7jSr1WqtXensN//Z9tZCZb7WXGy35tr12dZupm6crmR7OUqL/opS+3gndkf6i2359qTQ/xBuT/4N3Z7EuUxknqH2GEOlbgLqslQ3CXUy50hfJcVzrj9NKRLmUvy9sreS+tUYwr9IsoZKU4okD+rcuf5XFE+Fkach8kwr8hQUeY4++Dvi+scM5RMszDnWtx/91+wLdc168OmmrLQfpzotFZW6MUUGqUMbmaA6TGHF3qcS+sb5o2Bpfsxtk3SBfi+5XJ7wfwR+n4k7p/kv+z36L/s9+wTWoS2IfsR2p6ndUvy9srfStV1ZzifpdNrt1JHQv+XZStH8YRKucR5aUuix33nSF/pLifRVCqOv7jGOIwP0VSJ9Cf2/e/Sl9X/Co68jCn3Joy/UJbZl3kmxaL9scZBu2RaF/r9SblNNQn+iktsO0p9ZbZtK9PpQfuCb5C9In2b8NX8pEz2OtxbjOVYj3ymqw9jM8R9jvMQ2jKWcv2Gs5vwtKhPbbkd/H/6Ha6JP6dsk0lNdAepy2zv5FOPvcoyNsUSOPNGXYI542AdoI+3LCv9x4r9DbuUajgdjZZVrQh/pdDyWMcha+sE+3Nzt+cpsrd3o1NoDt+E0PaGfRkV0jWMxrvQtT/QnC70+nwZ7e0ir8IvoznvoMgn/H2Io13LbO69pY4S2K/TCu7jdL6PUTUEdxpCoTMffUV+IJXLkif4DZLtob9K+rPCfJP475Fause1OKfRTCn00PmdjGcVuse/W64uHPAkfr7Fs58GvfgqOkDXzHoABAA==",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1850,14 +1776,88 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "7Z3dbhtHEkbfRde+6K7+q86rLBYLx3ECA4Yd2M4CiyDvviPGQykSWQIxFuc7AG+CyJ4eHTepOiOSOPPn3S/vf/7jt/98+PTr5693P/3rz7uPn9+9/fbh86flqz/vrB3+7Ovvbz/df/n129sv3+5+surzzd37T78s/9ta/evN3a8fPr6/+ylb/+vN86OtpvVo63Y8eo4TB5c02/eDS+4eH5zbzOP70cv/l3Q83LycOr43Xw/vYxyPLimdOrr0sh5dc/rH0f9+c2f9tjXntmbctubc1vhta85tzbxtzZmtKem2Nee2Jt+25tzW2G1rzm1NuW3Nua2pt605tzW3q+GzW3O7Gj67Nber4bNbc7saPrs1t6vhc1tTb1fDZ7fmdjV8dmtuV8Nnt+Z2NXx2a+pta85tze1q+OzW3K6Gz27N7Wr47NbcrobPbs3tavjc1rTb1fDZrbldDZ/dGvWr4VYftubR4ae3xhbAlSTXtnFr1K+Gd9yaenprrDxsTXtha2ru60ZWSw9HDzt8h/bq3+HktVnt66Yuj/Nxxf3jfOIRqHZ8APqjg+eJg1up6w9tW/b24cHq7QAzlGBcCWZuheklnRqXJ2HynOU4XOds/3jSnPqhGvPhp8rt6XOsJzJ8JsMbGb5cE95S6kdJJcslhl/+deupsz1YJ9d5QK9X3vd5FEJKdT7dyLaVxr0fH9dHV2anaXrPR2t2t2c0XYpmXJVmzHn8CfH0/CnvUjRTiWYkKZosRWNSNJunX0sPF/VWHtPcn74pDdfRX/cfO177N4ChdJ07phCMJyUY8nWok69DvZDhKxm+keE7GX6Q4Z0MP7G/9c50XfSaHy7Man0BvfvxheLuIx8P7gfyjCU3LHnBklcseVMmn2mdLn3aeELeseQDS+5Y8kklz0laojG6tEVjdGmNxujSHo3RpUUao2NNmhNWpTlhXZoTVqY5cW2auTbNXJtmrk0z16aZa9PMtWnm2jRzbZq5Ns1cmxrXpsa1qXFtalybGtemxrWpcW1qXJuatk3r8Q2N2Z6ha9s0Qi/aNg3RtW0aomvbNETXtmmIrm3TEF3bpiG6tk1DdG2bhuhcmxauTSvXppVr08q1aeXatHJtWrk2rVybVq5NK9emlWvTxrVp49q0cW3auDZtXJs2rk0b16aNa9PGtWnj2rRzbdq5Nu1cm3auTa+bPvmx6Fybdq5NO9emnWvTzrXp4Np0cG06uDYdXJtuT+nsh8616eDadHBtOrg2HVybOtemzrWpc23qXJteN4b0Y9G5NnWuTZ1rU+fa1Lk21U4gxehcm2pHkGJ0rk21M0gxOtem4iGkEJ1rU/EUUoiOtamJt5BCdKxNTbyFFKJjbbqs56JjbWriLaQQHWtTE28hhehcm4q3kEJ0rk3FW0ghOtem4i2kEJ1rU/EWUojOtal4CylE59pUvIUUonNtKt5CCtG5NhVvIYXoXJuKt5BCdK5NuS0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQbHsLyb2v6LOkGD33fkTP3W0+Rj/gZC0cuy6Ot4engXt+4YH1dnxgfeSnD2zholcueuOidy764KI7F31S0UtKXPSsjB7dwb4kaZvG6NI2jdGlbRqjS9s0Rpe2aYwubdMYXdqmMbq0TUP0LG3TGJ1r08y1aebadHuzaD90rk0z16aZa9PMtWnm2tS4NjWuTY1rU+PadHuzaD90rk2Na1Pj2tS4NjWuTQvXpoVr08K1aeHadHuzaD90rk0L16aFa9PCtWnh2rRybVq5Nq1cm1auTbc3i/ZD59q0cm1auTatXJtWrk0b16ZN26bBJ55L07ZpiK5t0xD9ujYdc/p6tCdrj9EPOE0Lp2vhDC0c18KZUjg9aeFkLRzTwilaOFpTuWtN5a41lbvWVO5aU7lrTeWhNZWH1lQeWlN5aE3loTWVh9ZUHlpTeWhN5aE1lYfWVHatqexaU9m1prJrTWXXmsquNZVdayq71lR2ransWlN5ak3lqTWVp9ZUnlpTeWpN5ak1lbWbDuEbBtpNhxhd593UA87mad+qrd+g9RnjtOXN5O8Ht+XlzuPB1ts9Td2eXvihNFmK5qqRvTxnOU6POVuLn/O2TJv1WWnZnw2bmgqavqLpG5q+o+kHmt7R9FOYvo5VDd3q8dBc5wE9X7ljm/p6tCXLL0QDl3/beups/pxdOmQb9ZNqlg7ZxujSIdsYvXLRpUO2Mbp0yDZGlw7ZxujaIdvgY501a4dsI3TTzsKH6NpZ+BBdOwsfomtn4UN0aZvG6NpZ+BBdOwsfomtn4UN0rk2Na9PCtWnh2rRwbVq4Nt2eTdgPnWvTwrVp4dq0cG1auDatXJtWrk0r16aVa9Pt2YT90Lk2rVybVq5NK9emlWvTxrVp49q0cW3auDbdnk3YD51r08a1aePatHFt2rg27Vybdq5NO9emnWvT7bmL/dC5Nu1cm3auTTvXpp1r08G16eDadHBtOrg23Z4p2Q+da9PBteng2nRwbTq4NnWuTZ1rU+fa1Lk23Z6X2Q+da1Pn2tS5NnWuTZ1r08m16eTadHJtOrk23Z4F2g+da9PJtenk2nRybTqxNm0Ja9OWsDZtCWvTlrA2bQlr05awNm0Ja9OWsDZtCWvTlrg2zVybareQYnSuTbVbSDE616baLaQYnWtT7RZSjM61KbeF1LgtpMZtITVuC6lxW0iN20Jq4i2kIHHexFtIIbq2TUN0bZuG6No2jdDFW0ghurZNQ3Rtm4bo2jYN0bVtGqJzbSreQgrRuTYVbyGF6FybireQQnSuTcVbSCE616biLaQQnWtT8RZSiM61qXgLKUTn2lS8hRSic20q3kIK0bk2FW8hhehcm4q3kEJ0rk3FW0ghOtem4i2kEJ1rU/EWUojOtal4CylE59pUvIUUonNtKt5CCtG5NhVvIYXoXJuKt5BCdK5NxVtIITrXpuItpBCda1PxFlKIzrWpeAspROfaVLyFFKJzbSreQgrRuTYVbyGF6FybireQQnSuTcVbSCE616biLaQQnWtT8RZSiM61qXgLKUTn2lS8hRSiY23axVtIITrWpl28hRSiY23aE9amXbyFFKJjbdrFW0ghOtamfXsLyb2v6LOkGD33fkTP3W0+Rr/H2d43+rE4+bo43h6eBu75hQfW2/GB9ZGfPLDbm0X7oRcueuWiNy5656IPLrpz0ScW3ZIyetRx6SZt0xhd2qYxurRNY3Rpm8bo0jaN0aVtGqNL2zRGl7ZpjC5t0xC9cG1auDYtXJsWrk23N4v2Q+fatHBtWrg2LVybFq5NK9emlWvTyrVp5dp0e7NoP3SuTSvXppVr08q1aeXatHFt2rg2bVybNq5NtzeL9kPn2rRxbdq4Nm1cmzauTTvXpp1r0861aefadHuzaD90rk0716ada9POtWnn2nRwbTq4Nh1cmw6uTbc3i/ZD59p0cG06uDYdXJsOrk2da1Pn2tS5NnWuTbc3i/ZD59rUuTZ1rk2da1Pn2nRybTq5Np1cm06uTbc3i/ZD59p0cm06uTadXJtOrE1Hwtp0JKxNR9K2aVAUGUnbpiG6tk1D9OvadMzp69GerD1GP+B0LZyhheNaOFMK58oNoBdxshaOaeEULZyqhaM1lbPWVM5aUzlrTeWsNZVNayqb1lQ2ralsWlPZtKayaU1l05rKpjWVTWsqm9ZULlpTuWhN5aI1lYvWVC5aU7loTeWiNZWL1lQuWlO5aE3lqjWVq9ZUrlpTuWpN5ao1lavWVK5aU1m86RC9YSDedAjRdd5NvcfZ3mlo1dZv0PqMcVqp61Oylf7Q/rfe/qbJUjQmRXPV26nkOctxeszZWvyct2XarM9Ky/582GxvJOxK39D0HU0/0PSOpp9k+p6E6etY1dCtHg/Ndf6NfuU7lqW+Hm3J8gs35Vn+beups/lzdulblkX3Jxhd+pZlMXrlokvfsixGl75lWYwufcuyGF36lmUxuvYNQKOPdQ7tG4CG6No3AA3RtW8AGqJr3wA0RJe2aYyufQPQEF37BqAhuvYNQEN07RuAhuhcmzrXps61qXNt6lybbs8m7IfOtalzbepcmzrXps616eTadHJtOrk2nVybbs8m7IfOtenk2nRybTq5Np1Ym3rC2tQT1qaesDb1hLWpJ6xNPWFt6glrU09Ym3rC2tQT16aZa9PMtWnm2jRzbbo9YbEfOtemmWvTzLVp5to0c21qXJsa16bGtalxbbo9PbIfOtemxrWpcW1qXJsa16aFa9PCtWnh2rRwbbo9GbMfOtemhWvTwrVp4dq0cG1auTatXJtWrk0r16bbUz/7oXNtWrk2rVybVq5NK9emjWvTxrVp49q0cW163TzSj0Xn2rRxbdq4Nm1cmzauTTvXpp1rU+0WUozOtal2CylG59pUu4UUo3Ntqt1CitG5NuW2kJzbQnJuC8m5LSTntpCc20Jy8RZSkDh38RZSiK5t0xBd26YRungLKUTXtmmIrm3TEF3bpiG6tk1DdG2bhuhcm4q3kEJ0rk3FW0gRungLKUTn2lS8hRSic20q3kIK0bk2FW8hhehcm4q3kEJ0rE2neAspRMfadIq3kEJ0rE1nwtp0ireQQnSsTad4CylEx9p0ireQInTxFlKIzrWpeAspROfaVLyFFKJzbSreQgrRuTYVbyGF6FybireQQnSuTcVbSCE616biLaQQnWtT8RZSiM61qXgLKUTn2lS8hRSic20q3kIK0bk2FW8hhehcm4q3kEJ0rk3FW0ghOtem4i2kEJ1rU/EWUojOtal4CylE59pUvIUUonNtKt5CCtG5NhVvIYXoXJuKt5BCdK5NxVtIITrXpttbSO59RV9eS4vRc+9H9Nzd5mP0A87QwvHr4nh7eBq45xceWG/HB9ZHfvrATiz69mbRfuiZi25c9MJFr1z0xkXvXPShjB61LWaXtmmMLm3TEH1I2zRGl7ZpjC5t0xhd2qYxurRNY3Rpm8bo0jaN0bk2HVybDq5NnWtT59rUuTZ1rk23N4v2Q+fa1Lk2da5NnWtT59p0cm06uTadXJtOrk23N4v2Q+fadHJtOrk2nVybTqxNc0pYnS7sWJ8u7FihLuxYoy7sWKUu7FinLuxYqS7sWKsu7FitLuxgr2awVzPYqxns1Qz26vaE0Y7sYK9msFcz2KsZ7NUM9qqBvWpgrxrYqwb26vaY0Y7sYK8a2KsG9qqBvWpgrxawVwvYqwXs1QL26vas0Y7sYK8WsFcL2KsF7NUC9moFe7WCvVrBXq1gr24PHO3IDvZqBXu1gr1awV6t1/XqmNPXo315cegx+4GnJTGeLMZjYjxFjKeK8TQxni7GM8R4XIxHbD53sfncxeZzF5vPXWw+d7H53MXmcxebz11sPnex+dzF5vMQm89DbD4Psfk8xObzEJvPQ2w+D7H5PMTm8xCbz0NsPrvYfHax+exi89nF5rOLzWcXm88uNp9dbD672Hx2sfk8hebz8sXPXz58/Pjht/98/Pzu7bcPnz99vV+c7v9z5gPcw9YX+60eT5brPJwt3x95+pOwvczvCz21RwvH/bac/gBqvKRdvqRfvmRcvsQvX3Jyq92OS6o/XXL6o3Txknz5Ert8Sbl8Sb18Sbt8Sb98ybh8iV++5PSj7+tE8Dn/seT5T3np6ztwZTz8UJbm96c//eGQH3f6/Lqnt9c9fXnd09fXPX173dP31z39+IGn9/Ls9P66p5+vevrTb1NPW9U/y3g6R06/kxwvscuXlMuX1MuXtMuX9MuXjIuXnH55OF4yL15y+kVWq+sTxvp4+oQ5/TpovMQuX1IuX1IvX9IuX9IvX3Ly0bcx1iXz2U/l6Ref4iXz4iWnX8KJl+TLl9jlS8qFS/5avvzv2y8f3v788f39bxb3f/vHp3frLxrLl9/+9/v6N+uvIr9/+fzu/S9/fHl//0vJo99H7nfF8hvrx980Dn/U85veF7hDUMDnm5mXb7t86/8D",
       "brillig_names": [
         "notify_enqueued_public_function_call_wrapper",
         "call_private_function_internal",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "parameters": [],
+        "return_type": null,
+        "error_types": {
+          "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"
+              }
+            ]
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
+          "6753155520859132764": {
+            "error_kind": "string",
+            "string": "Failed to deliver note"
+          },
+          "8830323656616886390": {
+            "error_kind": "string",
+            "string": "Got a public log emitted by a different contract"
+          },
+          "13649294680379557736": {
+            "error_kind": "string",
+            "string": "extend_from_bounded_vec out of bounds"
+          },
+          "14657895983200220173": {
+            "error_kind": "string",
+            "string": "Attempted to read past the length of a CapsuleArray"
+          },
+          "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": "public_dispatch",
@@ -1991,47 +1991,47 @@
     }
   },
   "file_map": {
-    "116": {
+    "118": {
       "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 process_log = generate_process_log();\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        $process_log\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_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform message discovery, resulting in new private notes, partial notes and events.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll\n                // not be modified by the macros that alter unconstrained functions. As such, we need to manually inject\n                // the unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_ciphertext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\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            unconstrained fn process_log(\n                _log_ciphertext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\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"
     },
-    "124": {
+    "126": {
       "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"
     },
-    "145": {
+    "147": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "146": {
+    "148": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/capsules.nr",
       "source": "use protocol_types::{address::AztecAddress, traits::{Deserialize, Serialize}};\n\n/// Stores arbitrary information in a per-contract non-volatile database, which can later be retrieved with `load`. If\n/// data was already stored at this slot, it is overwritten.\npub unconstrained fn store<T, let N: u32>(contract_address: AztecAddress, slot: Field, value: T)\nwhere\n    T: Serialize<N>,\n{\n    let serialized = value.serialize();\n    store_oracle(contract_address, slot, serialized);\n}\n\n/// Returns data previously stored via `storeCapsule` in the per-contract non-volatile database. Returns Option::none() if\n/// nothing was stored at the given slot.\npub unconstrained fn load<T, let N: u32>(contract_address: AztecAddress, slot: Field) -> Option<T>\nwhere\n    T: Deserialize<N>,\n{\n    let serialized_option = load_oracle::<N>(contract_address, slot, N);\n    serialized_option.map(|arr| Deserialize::deserialize(arr))\n}\n\n/// Deletes data in the per-contract non-volatile database. Does nothing if no data was present.\npub unconstrained fn delete(contract_address: AztecAddress, slot: Field) {\n    delete_oracle(contract_address, slot);\n}\n\n/// Copies a number of contiguous entries in the per-contract non-volatile database. This allows for efficient data\n/// structures by avoiding repeated calls to `loadCapsule` and `storeCapsule`.\n/// Supports overlapping source and destination regions (which will result in the overlapped source values being\n/// overwritten). All copied slots must exist in the database (i.e. have been stored and not deleted)\npub unconstrained fn copy(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {\n    copy_oracle(contract_address, src_slot, dst_slot, num_entries);\n}\n\n#[oracle(storeCapsule)]\nunconstrained fn store_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    values: [Field; N],\n) {}\n\n/// We need to pass in `array_len` (the value of N) as a parameter to tell the oracle how many fields the response must\n/// have.\n///\n/// Note that the oracle returns an Option<[Field; N]> because we cannot return an Option<T> directly. That would\n/// require for the oracle resolver to know the shape of T (e.g. if T were a struct of 3 u32 values then the expected\n/// response shape would be 3 single items, whereas it were a struct containing `u32, [Field;10], u32` then the expected\n/// shape would be single, array, single.). Instead, we return the serialization and deserialize in Noir.\n#[oracle(loadCapsule)]\nunconstrained fn load_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    slot: Field,\n    array_len: u32,\n) -> Option<[Field; N]> {}\n\n#[oracle(deleteCapsule)]\nunconstrained fn delete_oracle(contract_address: AztecAddress, slot: Field) {}\n\n#[oracle(copyCapsule)]\nunconstrained fn copy_oracle(\n    contract_address: AztecAddress,\n    src_slot: Field,\n    dst_slot: Field,\n    num_entries: u32,\n) {}\n\nmod test {\n    // These tests are sort of redundant since we already test the oracle implementation directly in TypeScript, but\n    // they are cheap regardless and help ensure both that the TXE implementation works accordingly and that the Noir\n    // oracles are hooked up correctly.\n\n    use crate::{\n        oracle::capsules::{copy, delete, load, store},\n        test::{helpers::test_environment::TestEnvironment, mocks::mock_struct::MockStruct},\n    };\n    use protocol_types::{address::AztecAddress, traits::{FromField, ToField}};\n\n    unconstrained fn setup() -> AztecAddress {\n        let env = TestEnvironment::new();\n        env.contract_address()\n    }\n\n    global SLOT: Field = 1;\n\n    #[test]\n    unconstrained fn stores_and_loads() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), value);\n    }\n\n    #[test]\n    unconstrained fn store_overwrites() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n\n        let new_value = MockStruct::new(7, 8);\n        store(contract_address, SLOT, new_value);\n\n        assert_eq(load(contract_address, SLOT).unwrap(), new_value);\n    }\n\n    #[test]\n    unconstrained fn loads_empty_slot() {\n        let contract_address = setup();\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_stored_value() {\n        let contract_address = setup();\n\n        let value = MockStruct::new(5, 6);\n        store(contract_address, SLOT, value);\n        delete(contract_address, SLOT);\n\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn deletes_empty_slot() {\n        let contract_address = setup();\n\n        delete(contract_address, SLOT);\n        let loaded_value: Option<MockStruct> = load(contract_address, SLOT);\n        assert_eq(loaded_value, Option::none());\n    }\n\n    #[test]\n    unconstrained fn copies_non_overlapping_values() {\n        let contract_address = setup();\n\n        let src = 5;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 10;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_src_ahead() {\n        let contract_address = setup();\n\n        let src = 1;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 2;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[1] and src[2] should have been overwritten since they are also dst[0] and dst[1]\n        assert_eq(load(contract_address, src).unwrap(), values[0]); // src[0] (unchanged)\n        assert_eq(load(contract_address, src + 1).unwrap(), values[0]); // dst[0]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[1]); // dst[1]\n    }\n\n    #[test]\n    unconstrained fn copies_overlapping_values_with_dst_ahead() {\n        let contract_address = setup();\n\n        let src = 2;\n\n        let values = [MockStruct::new(5, 6), MockStruct::new(7, 8), MockStruct::new(9, 10)];\n        store(contract_address, src, values[0]);\n        store(contract_address, src + 1, values[1]);\n        store(contract_address, src + 2, values[2]);\n\n        let dst = 1;\n        copy(contract_address, src, dst, 3);\n\n        assert_eq(load(contract_address, dst).unwrap(), values[0]);\n        assert_eq(load(contract_address, dst + 1).unwrap(), values[1]);\n        assert_eq(load(contract_address, dst + 2).unwrap(), values[2]);\n\n        // src[0] and src[1] should have been overwritten since they are also dst[1] and dst[2]\n        assert_eq(load(contract_address, src).unwrap(), values[1]); // dst[1]\n        assert_eq(load(contract_address, src + 1).unwrap(), values[2]); // dst[2]\n        assert_eq(load(contract_address, src + 2).unwrap(), values[2]); // src[2] (unchanged)\n    }\n\n    #[test(should_fail_with = \"copy empty slot\")]\n    unconstrained fn cannot_copy_empty_values() {\n        let contract_address = setup();\n\n        copy(contract_address, SLOT, SLOT, 1);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_store_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let value = MockStruct::new(5, 6);\n        store(other_contract_address, SLOT, value);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_load_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        let _: Option<MockStruct> = load(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_delete_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        delete(other_contract_address, SLOT);\n    }\n\n    #[test(should_fail_with = \"not allowed to access\")]\n    unconstrained fn cannot_copy_other_contract() {\n        let contract_address = setup();\n        let other_contract_address = AztecAddress::from_field(contract_address.to_field() + 1);\n\n        copy(other_contract_address, SLOT, SLOT, 0);\n    }\n}\n"
     },
-    "147": {
+    "149": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(notifyEnqueuedPublicFunctionCall)]\nunconstrained fn notify_enqueued_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_enqueued_public_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_enqueued_public_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_enqueued_public_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a public call has been enqueued, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_enqueued_public_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\n#[oracle(notifySetPublicTeardownFunctionCall)]\nunconstrained fn notify_set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _calldata_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) {}\n\nunconstrained fn notify_set_public_teardown_function_call_wrapper(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    notify_set_public_teardown_function_call_oracle(\n        contract_address,\n        calldata_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_public_teardown_function_call(\n    contract_address: AztecAddress,\n    calldata_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) {\n    // Safety: Notifies the simulator that a teardown call has been set, allowing it to prepare hints for the AVM to process this call.\n    unsafe {\n        notify_set_public_teardown_function_call_wrapper(\n            contract_address,\n            calldata_hash,\n            side_effect_counter,\n            is_static_call,\n        )\n    }\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "148": {
+    "150": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "158": {
+    "160": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/message_discovery.nr",
       "source": "use crate::discovery::private_notes::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {\n    deliver_note_oracle(\n        contract_address,\n        storage_slot,\n        nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n        recipient,\n    )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n    pub log_content: BoundedVec<Field, PUBLIC_LOG_DATA_SIZE_IN_FIELDS>,\n    pub tx_hash: Field,\n    /// The array of new note hashes created by `tx_hash`\n    pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    /// The first nullifier created by `tx_hash`\n    pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option<LogWithTxData> {\n    get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option<LogWithTxData> {}\n"
     },
-    "187": {
+    "189": {
       "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"
     },
-    "189": {
+    "191": {
       "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"
     },
-    "190": {
+    "192": {
       "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"
     },
-    "191": {
+    "193": {
       "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"
     },
@@ -2039,35 +2039,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"
     },
-    "263": {
+    "265": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::{pow, sqrt},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "280": {
+    "282": {
       "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"
     },
-    "281": {
+    "283": {
       "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"
     },
-    "295": {
+    "297": {
       "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"
     },
-    "298": {
+    "300": {
       "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"
     },
-    "337": {
+    "339": {
       "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"
     },
-    "353": {
+    "355": {
       "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"
     },
-    "356": {
+    "358": {
       "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"
     },
@@ -2105,7 +2105,7 @@
     },
     "77": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/mod.nr",
-      "source": "// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse dep::protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n    PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n///         Option::some(\n///             aztec::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowldge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    private_logs::fetch_and_process_private_tagged_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    partial_notes::fetch_and_process_public_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n}\n"
+      "source": "use crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\nuse protocol_types::{address::AztecAddress, debug_log::debug_log};\n\npub mod private_logs;\npub mod private_notes;\npub mod partial_notes;\npub mod nonce_discovery;\n\n/// We reserve two fields in the note private log that are not part of the note content: one for the storage slot, and\n/// one for the combined log and note type ID.\nglobal PRIVATE_LOG_EXPANDED_METADATA_LEN: u32 = 1;\n\n/// The maximum length of the log's content, i.e. after log type ID and metadata extraction.\npub global MAX_LOG_CONTENT_LEN: u32 =\n    PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS - PRIVATE_LOG_EXPANDED_METADATA_LEN;\n\nuse private_notes::MAX_NOTE_PACKED_LEN;\n\npub struct NoteHashAndNullifier {\n    /// The result of NoteHash::compute_note_hash\n    pub note_hash: Field,\n    /// The result of NoteHash::compute_nullifier_unconstrained (since all of message discovery is unconstrained)\n    pub inner_nullifier: Field,\n}\n\n/// A function which takes a note's packed content, address of the emitting contract, nonce, storage slot and note type\n/// ID and attempts to compute its note hash (not siloed by nonce nor address) and inner nullifier (not siloed by\n/// address).\n///\n/// This function must be user-provided as its implementation requires knowledge of how note type IDs are allocated in a\n/// contract. The `#[aztec]` macro automatically creates such a contract library method called\n/// `_compute_note_hash_and_nullifier`, which looks something like this:\n///\n/// ```\n/// |packed_note, contract_address, nonce, storage_slot, note_type_id| {\n///     if note_type_id == MyNoteType::get_id() {\n///         assert(packed_note.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///\n///         let note = MyNoteType::unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n///\n///         let note_hash = note.compute_note_hash(storage_slot);\n///         let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n///             RetrievedNote{ note, contract_address, metadata: SettledNoteMetadata::new(nonce).into() },\n///             storage_slot\n///         );\n///\n///         let inner_nullifier = note.compute_nullifier_unconstrained(note_hash_for_nullify);\n///\n///         Option::some(\n///             aztec::discovery::NoteHashAndNullifier {\n///                 note_hash, inner_nullifier\n///             }\n///         )\n///     } else if note_type_id == MyOtherNoteType::get_id() {\n///           ... // Similar to above but calling MyOtherNoteType::unpack_content\n///     } else {\n///         Option::none() // Unknown note type ID\n///     };\n/// }\n/// ```\ntype ComputeNoteHashAndNullifier<Env> = unconstrained fn[Env](/* packed_note */BoundedVec<Field, MAX_NOTE_PACKED_LEN>, /* storage_slot */ Field, /* note_type_id */ Field, /* contract_address */ AztecAddress, /* nonce */ Field) -> Option<NoteHashAndNullifier>;\n\n/// Performs the message discovery process, in which private are downloaded and inspected to find new private notes,\n/// partial notes and events, etc., and pending partial notes are processed to search for their completion logs.\n/// This is the mechanism via which a contract updates its knowledge of its private state.\n///\n/// Receives the address of the contract on which discovery is performed along with its\n/// `compute_note_hash_and_nullifier` function.\npub unconstrained fn discover_new_messages<Env>(\n    contract_address: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log(\"Performing message discovery\");\n\n    private_logs::fetch_and_process_private_tagged_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n\n    partial_notes::fetch_and_process_public_partial_note_completion_logs(\n        contract_address,\n        compute_note_hash_and_nullifier,\n    );\n}\n"
     },
     "78": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/nonce_discovery.nr",
@@ -2117,9 +2117,9 @@
     },
     "80": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/discovery/private_logs.nr",
-      "source": "use crate::{oracle::message_discovery::sync_notes, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n    debug_log::{debug_log, debug_log_format},\n};\n\nuse crate::discovery::{\n    ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n    partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n    private_notes::process_private_note_log,\n};\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::decrypt_log;\n// TODO(#12750): don't make this value assume we're using AES.\nuse crate::encrypted_logs::log_assembly_strategies::default_aes128::note::encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n    _contract_address: AztecAddress,\n    _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n    // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n    // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n    // decrypted log, letting us continue the work outside of PXE.\n    sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log<Env>(\n    contract_address: AztecAddress,\n    log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n    let log_plaintext = decrypt_log(log, recipient);\n\n    // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n    // currently just have two log types: 0 for private notes and 1 for partial notes. This will likely be expanded and\n    // improved upon in the future to also handle events, etc.\n\n    let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n    if log_type_id == 0 {\n        debug_log(\"Processing private note log\");\n\n        process_private_note_log(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            recipient,\n            compute_note_hash_and_nullifier,\n            log_metadata,\n            log_content,\n        );\n    } else if log_type_id == 1 {\n        debug_log(\"Processing partial note private log\");\n\n        process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n    } else {\n        // TODO(#11569): handle events\n        debug_log_format(\n            \"Unknown log type id {0} (probably belonging to an event log)\",\n            [log_type_id as Field],\n        );\n    }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n///  - an initial field called the 'expanded metadata'\n///  - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plainext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u64, of which:\n///  - the upper 57 bits are the log type id\n///  - the remaining 7 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [  log_type_id   |  log_metadata ]\n///                        <--- 57 bits --->|<--- 7 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (u64, u64, BoundedVec<Field, MAX_LOG_CONTENT_LEN>) {\n    assert(\n        log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the log encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n    );\n\n    // See the documentation of this function for a description of the log layout\n    let expanded_log_metadata = log_plaintext.get(0);\n\n    let log_type_id = ((expanded_log_metadata as u64) / 128);\n    let log_metadata = ((expanded_log_metadata as u64) % 128);\n\n    let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n    (log_type_id, log_metadata, log_content)\n}\n"
+      "source": "use crate::{\n    discovery::{\n        ComputeNoteHashAndNullifier, MAX_LOG_CONTENT_LEN,\n        partial_notes::process_partial_note_private_log, PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        private_notes::process_private_note_log,\n    },\n    encrypted_logs::{\n        log_assembly_strategies::default_aes128::aes128::AES128,\n        log_encryption::LogEncryption,\n        log_type::{PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID, PRIVATE_NOTE_LOG_TYPE_ID},\n        metadata_packing::from_expanded_metadata,\n    },\n    oracle::message_discovery::sync_notes,\n    utils::array,\n};\n\nuse protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n    debug_log::{debug_log, debug_log_format},\n};\n\n// TODO(#12750): don't make these values assume we're using AES.\nuse crate::encrypted_logs::log_encryption::PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS;\n\n/// Searches for private logs that signal new private notes that are then delivered to PXE, or new partial notes that\n/// are stored in the PXE capsules so that `fetch_and_process_public_partial_note_completion_logs` can later search for\n/// public logs that will complete them.\npub unconstrained fn fetch_and_process_private_tagged_logs<Env>(\n    _contract_address: AztecAddress,\n    _compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    // We will eventually fetch tagged logs, decrypt and process them here, but for now we simply call the `syncNotes`\n    // oracle. This has PXE perform tag synchronization, log download, decryption, and finally calls to the the\n    // `process_log` contract function with the decrypted payload, which will in turn call `do_process_log` with a\n    // decrypted log, letting us continue the work outside of PXE.\n    sync_notes();\n}\n\n/// Processes a log's ciphertext by decrypting it and then searching the plaintext for private notes or partial notes.\n///\n/// Private notes result in nonce discovery being performed prior to delivery, which requires knowledge of the\n/// transaction hash in which the notes would've been created (typically the same transaction in which the log was\n/// emitted), along with the list of unique note hashes in said transaction and the `compute_note_hash_and_nullifier`\n/// function.\n///\n/// Partial notes result in a pending partial note entry being stored in a PXE capsule, which will later be retrieved to\n/// search for the note's completion public log.\npub unconstrained fn do_process_log<Env>(\n    contract_address: AztecAddress,\n    log: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: ComputeNoteHashAndNullifier<Env>,\n) {\n    debug_log_format(\"Processing log with tag {0}\", [log.get(0)]);\n\n    // The tag is ignored for now.\n    let ciphertext = array::subbvec(log, 1);\n\n    let log_plaintext = AES128::decrypt_log(ciphertext, recipient);\n\n    // The first thing to do after decrypting the log is to determine what type of private log we're processing. We\n    // have 3 log types: private note logs, partial note logs and event logs.\n\n    let (log_type_id, log_metadata, log_content) = decode_log_plaintext(log_plaintext);\n\n    if log_type_id == PRIVATE_NOTE_LOG_TYPE_ID {\n        debug_log(\"Processing private note log\");\n\n        process_private_note_log(\n            contract_address,\n            tx_hash,\n            unique_note_hashes_in_tx,\n            first_nullifier_in_tx,\n            recipient,\n            compute_note_hash_and_nullifier,\n            log_metadata,\n            log_content,\n        );\n    } else if log_type_id == PARTIAL_NOTE_PRIVATE_LOG_TYPE_ID {\n        debug_log(\"Processing partial note private log\");\n\n        process_partial_note_private_log(contract_address, recipient, log_metadata, log_content);\n    } else {\n        // TODO(#11569): handle events\n        debug_log_format(\n            \"Unknown log type id {0} (probably belonging to an event log)\",\n            [log_type_id as Field],\n        );\n    }\n}\n\n/// Decodes a log's plaintext following aztec-nr's standard log encoding.\n///\n/// The standard private log layout is composed of:\n///  - an initial field called the 'expanded metadata'\n///  - an arbitrary number of fields following that called the 'log content'\n///\n/// ```\n/// log_plaintext: [ log_expanded_metadata, ...log_content ]\n/// ```\n///\n/// The expanded metadata itself is (currently) interpreted as a u128, of which:\n///  - the upper 64 bits are the log type id\n///  - the lower 64 bits are called the 'log metadata'\n///\n/// ```\n/// log_expanded_metadata: [  log_type_id    |  log_metadata  ]\n///                        <---  64 bits --->|<--- 64 bits --->\n/// ```\n///\n/// The meaning of the log metadata and log content depend on the value of the log type id. Note that there is\n/// nothing special about the log metadata, it _can_ be considered part of the content. It just has a different name\n/// to make it distinct from the log content given that it is not a full field.\nunconstrained fn decode_log_plaintext(\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_PLAINTEXT_SIZE_IN_FIELDS>,\n) -> (u64, u64, BoundedVec<Field, MAX_LOG_CONTENT_LEN>) {\n    assert(\n        log_plaintext.len() >= PRIVATE_LOG_EXPANDED_METADATA_LEN,\n        f\"Invalid log plaintext: all logs must be decrypted into at least {PRIVATE_LOG_EXPANDED_METADATA_LEN} fields\",\n    );\n\n    // If PRIVATE_LOG_EXPANDED_METADATA_LEN is changed, causing the assertion below to fail, then the destructuring of\n    // the log encoding below must be updated as well.\n    std::static_assert(\n        PRIVATE_LOG_EXPANDED_METADATA_LEN == 1,\n        \"unexpected value for PRIVATE_LOG_EXPANDED_METADATA_LEN\",\n    );\n\n    // See the documentation of this function for a description of the log layout\n    let expanded_log_metadata = log_plaintext.get(0);\n    let (log_metadata, log_type_id) = from_expanded_metadata(expanded_log_metadata);\n    let log_content = array::subbvec(log_plaintext, PRIVATE_LOG_EXPANDED_METADATA_LEN);\n\n    (log_type_id, log_metadata, log_content)\n}\n"
     },
-    "95": {
+    "97": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__PUBLIC_CALLDATA, GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Same as `hash_args_array`, but takes a slice instead of an array.\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n// Same as `hash_calldata_array`, but takes a slice instead of an array.\npub fn hash_calldata(calldata: [Field]) -> Field {\n    if calldata.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(calldata, GENERATOR_INDEX__PUBLIC_CALLDATA)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }