@aztec/protocol-contracts 0.77.0 → 0.77.1

package/artifacts/MultiCallEntrypoint.json

@@ -3,26 +3,6 @@
   "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
   "name": "MultiCallEntrypoint",
   "functions": [
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "ZY5bCsMgEEX3Mt9+RO0r2UoowSSTIIgGo4Ui7r1jCFTan8vc4XA5CWYc4zpou7gduj6BcZMK2llqKTMYvTZGr0P9hqYElwe/b8qWugflA3RctrJhgHY+7rukjUUbpCYemf3xshUnfeH8y95EfmaqL+W1Gg2eNku0UyUX3hv+eG7eTThHj8W4kqXs+ZWJhmZp+gM=",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "process_log",
       "is_unconstrained": true,
@@ -130,7 +110,7 @@
         "return_type": null
       },
       "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": "tZbdCoMgGIbvxWMP0tKv7VbGGFY2BLGwGozo3qdjP7EdvyfRK58+HvjAu7LONsv14kI/TOx4WpkfWjO7IaS0bpw10Xnvrpf9MivyRyj93DCNJuQ8zSbO7ChKeZCc2dDl/7KS6ZDeeZuSrDf+N0/vYaLPpBLbmScAoQE1GnAAA3SBBgg0QKIBJRpQoQEKDUCbrNEma7TJGm0yoU0mtMmENpnQJhPaZEKbTGiTCW0yQU3eUrqZ6Ezj7avh9Etod4Vnvo/2p/uMcWhtt0SbW9C3AOXXWEmuZL52tlfUBRe1SpAEegA=",
+      "debug_symbols": "tZZBCsMgEEXv4tpFNNWxvUopxSSmCGKCSQol5O7VUtrQrv9GZmT0ufDBX1nnmuV29bEfJnY6rywMrZ39EHO3bpw1yYfgb9f9NqvKIpR+HZhGG0s/zTbN7CRqaQxnLnalrmuTL+l9cLmTuf6bJ/keJvpMKrFdeAYQGmDQgCMYoCs0QKABEg2o0YADGqDQALTJGm2yRpus0SYT2mRCm0xokwltMqFNJrTJhDaZ0CYT1OQtd3ebvG2CeyecfontLvDMj9H9ZJ8xDa3rluRKCvoGoPIbD5IrWZ5d7BWm4sKoDMmgJw==",
       "brillig_names": [
         "process_log"
       ]
@@ -1830,7 +1810,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "7Z3RbhtHEkX/Rc9+6K7u6u7KrywWCyfxLgwYduA4CyyC/PtSskkqMlkCMZZ4D8CXQIqnR8dNqs7IpM78effru5//+M+/3n/896ff7376x593Hz798vbL+08fd5/9eWf+8P9+/+3tx/tPf//y9vOXu5+sj/nm7t3HX3cferO/3tz9+/2Hd3c/VZt/vfn+aCtjf7TZOhwdcergtQ6njlHyg6tH3R+9+7gdD7dVTh0/fO0PH3Mej45T3LWNtj+61/K3o//55s7GbWvObc28bc25rVm3rTm3NXHbmjNb08pta85tTb1tzbmtsdvWnNuadtuac1vTb1tzbmtuV8Nnt+Z2NXx2a25Xw2e35nY1fHZrblfD57am366Gz27N7Wr47NbcrobPbs3tavjs1vTb1pzbmtvV8NmtuV0Nn92a29Xw2a25XQ2f3Zrb1fC5rfHb1fDZrbldDZ/dGvWrYe/HrRnrma2xageS2n3j1qhfDV9xa/rprSn1uDXtma3p1f3b0b1GPRw94+Er+It/hZPXZn3sN7WvOKwY9eQj0I4PwDiefowTB+9o49vB3rwfN3TYA8xUgllKMLEVZpgdxuXwHKbGiMMTP+ajZ/48+R3bSj88IVuZ5clzbBQyfCXDGxm+vSa8lXb4drXiLZ7S9NfdytkPlzexSn9K41tp4kgT9wgpzXCPRxdb/pRmSNHMV6WZ0Q9jfu6e9U9plhRNKNHMIkVTpWhMimbz9OsxDhdD9W/T7/70rjRc51ASz5wv/TPAVLrSnSEEs4oSDPlKdJGvRFcjw3cyvJPhBxl+kuEXGT6ULj+ivC5N9MM/0JaYI9/KsQ7/+jvWo4vWh4vKqFhyw5I3LHnHkrsyeZT9Tx4jbD4hH1jyiSVfWPKgktciLdEcXdqiObq0RnN0aY/m6NIizdGxJq0Fq9JasC6tBSvTWrg2rVybVq5NK9emlWvTyrVp5dq0cm1auTatXJtWrk2Na1Pj2tS4NjWuTY1rU+Pa1Lg2Na5NjWtT49q0cW3auDZtXJs2rk2btk0Pb2gd4d+ha9s0Rde2aYqubdMUXdumKbq2TTP0rm3TFF3bpim6tk1TdG2bpuhcm3auTTvXpp1r0861aefa1Lk2da5NnWtT59rUuTZ1rk2da1Pn2tS5NnWuTQfXpoNr08G16eDa9HXjJz8WnWvTwbXp4Np0cG06uDadXJtOrk0n16aTa9PtMZ3roXNtOrk2nVybTq5NJ9emi2vTxbXp4tp0cW36un2jH4vOteni2nRxbbq4Nl1cm2onkHJ0rk21I0g5Otem2hmkHJ1rU/EQUorOtal4CilFx9rUxFtIKTrWpibeQkrRsTa1grWpibeQUnSsTU28hZSiY21q4i2kDF28hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFJ1rU/EWUorOtal4CylF59pUvIWUonNtKt5CStG5NhVvIaXoXJuKt5BSdK5NuS0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kBq3hdS4LaTGbSE1bgupFaxNG7eF1LgtpMZtITVuC6lxW0iN20Jq3BZS47aQGreF1LgtpMZtITVuC6lxW0iN20Jq3BZS47aQGreF1LgtpMZtITVuC6lxW0iN20Jq3BZS295CiiN6jJGj1+Eeh7/onP4Y/QEnpHC2N4suw5kxDjjL5jMP7PLDA7tmffLAbm8WXQ/duOiNi9656M5FH1z0yUVfXPRQRo/ih2sNe3qt0aVtmqNL2zRHl7Zpji5t0xxd2qY5urRNc3Rpm+bo0jbN0aVtmqNzbepcmzrXps61qXNtur1ZdD10rk2da1Pn2tS5NnWuTQfXpoNr08G16eDadHuz6HroXJsOrk0H16aDa9PBtenk2nRybTq5Np1cm25vFl0PnWvTybXp5Np0cm06uTZdXJsurk0X16aLa9PtzaLroXNturg2XVybLq5Nl7ZNs3c8h7ZNU3Rtm6bor2vTeYTZffzoTXTf3tgdTQuna+G4Fs7QwplaOEsLJ5RweilaOFULR2oq9yI1lXuRmsq9SE3lXqSmci9SU7kXqanci9ZUrlpTuWpN5ao1lavWVK5aU7lqTeWqNZWr1lSuWlO5ak1l05rKpjWVTWsqm9ZUNq2pbFpT2bSmsmlNZdOayqY1lZvWVG5aU7lpTeWmNZW1mw7ZCwZdu+mQo+u8mvqAs3naezs8y3zUHMdb2yd1vHk/HGzDvtIsKZpQoumvGtnbPbWiHZ5ms5b8OW+t9Prt8N3Hszx9nvWKpjc0fUPTdzS9o+kHmn4K03vsTz39iFG9fEV/5Y5tO4jKirf4biel27RZEqm7dJs2R5du0+bo0m3aHF26TZujdy66dJs2R9du0ybv1Oyu3aZN0bVL7ym6duk9Qx/apfcUXbv0nqJrl95TdO3Se4oubdMcXbv0nqJzbTq4Nh1cmw6uTSfXppNr08m16eTadHsJ4XroXJtOrk0n16aTa9PJteni2nRxbbq4Nl1cm24vIVwPnWvTxbXp4tp0cW26uDYNrk2Da9Pg2jS4Nt1eWLgeOtemwbVpcG0aXJsG1qZesDb1grWpF6xNvWBt6gVrUy9Ym3rB2tQL1qZesDb1wrVp5dq0cm1auTatXJtuL5pcD51r08q1aeXatHJtWrk2Na5NjWtT49rUuDbdXqK5HjrXpsa1qXFtalybGtemjWvTxrVp49q0cW26vSB0PXSuTRvXpo1r08a1aePatHNt2rk27Vybdq5NXzd09GPRuTbtXJt2rk0716baLaQUXbuFlKNzbardQsrRuTbVbiHl6FybcltIzm0hObeF5NwWknNbSM5tITm3heTcFpJzW0jObSE5t4Xk3BaSc1tIzm0hObeF5NwWknNbSM5tITm3heTcFpJzW0jObSE5t4Xk3BaSc1tIzm0hObeF5NwWkou3kJKbgbl4CylF17Zpiq5t0xRd26YpurZNM3TxFlKKrm3TFF3bpim6tk1TdK5NxVtIKTrXpuItpBSda1PxFlKCPsRbSCk61qZDvIWUomNtOgrWpkO8hZSiY206xFtIKTrWpkO8hZShi7eQUnSuTcVbSCk616biLaQUnWtT8RZSis61qXgLKUXn2lS8hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFJ1rU/EWUorOtal4CylF59pUvIWUonNtKt5CStG5NhVvIaXoXJuKt5BSdK5NxVtIKTrXpuItpBSda1PxFlKKzrWpeAspRefaVLyFlKJzbSreQkrRuTYVbyGl6FybireQUnSuTcVbSCk616biLaQUnWtT8RZSis61qXgLKUXn2lS8hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFJ1rU/EWUorOtal4CylF59p0ewspjugxRo5ed/88G4e/6Jz+GP0Bx7VwxuvizBgHnPWoW3X6gV1+eGDXrE8f2MlFX1z0wKJvbxZdD71y0Y2L3rjonYvuyuhZd3GEtE1zdGmb5ujSNs3RpW2aoc8ibdMcXdqmObq0TXN0aZvm6NI2zdGxNp0Fa9NZsDadBWvTWbg2rVybVq5NK9emlWvT7c2i66FzbVq5Nq1cm1auTSvXpsa1qXFtalybGtem25tF10Pn2tS4NjWuTY1rU+PatHFt2rg2bVybNq5NtzeLrofOtWnj2rRxbdq4Nm1cm3auTTvXpp1r08616fZm0fXQuTbtXJt2rk0716ada1Pn2tS5NnWuTZ1r0+3Nouuhc23qXJs616bOtalzbTq4Nh1cmw6uTQfXptubRddD59p0cG06uDYdXJsOrk0n16aTa9PJtenk2nR7s+h66FybTq5Np7ZNk6LInNo2TdG1bZqhr9e16TzC7D5+9EvqX8Mpc1UtHNPCaVo4XQvHtXCGFs7UwllaOCGFE1pTObSmcmhN5dCayqE1lUNrKofWVA6tqRxaUzmkpvIqUlN5FampvIrUVF5FaiqvIjWVV5GayqtITeVVpKbyKlJTeRWtqVy1pnLVmspVaypXralctaZy1ZrKVWsqV62pXLWmctWayqY1lU1rKos3HZIXDJZ40yFF7zLoDzibp723w7PMR81xvLV9st6b98PBNuwrzZCimVI0r3o7ld1TK9rhaTZryZ/z1kqv3w7ffTzLd8+zINO3gqavaHpD0zc0fUfTuzC9x/7U048Y1ctX9Fe+Y1k7iMqKt/huJ6XvQpbdcmA16buQ5ejSdyFL0bv0XchydOm7kOXo0nchy9Gl70KWo3dl9Oydmqtr39MzRde+p2eKrn1PzxRd+56eKbr2PT0zdJe2aY6ufU/PFF37np4puvY9PVN0rk2da1Pn2tS5NnWuTZ1r08G16eDadHBtOrg23V5CuB4616aDa9PBteng2nRwbTq5Np1cm06uTSfXpttLCNdD59p0cm06uTadXJtOrk0X16aLa9PFteni2nR7ueF66FybLq5NF9emi2vTxbVpcG0aXJsG16bBten24sb10Lk2Da5Ng2vT4No0sDaNgrVpFKxNo2BtGgVr0yhYm0bB2jQK1qZRsDaNgrVpFK5NK9emlWvTyrVp5dp0e+Hmeuhcm1auTSvXppVr08q1qXFtalybGtemxrXp9oLQ9dC5NjWuTY1rU+Pa1Lg2bVybNq5NG9emjWvT100c/Vh0rk0b16baLaQcnWtT7RZSiq7dQsrRuTbVbiHl6FybcltIwW0hBbeFFNwWUnBbSMFtIQW3hRTcFlJwW0jBbSEFt4UU3BZScFtIwW0hBbeFFNwWUnBbSMFtIQW3hRTcFlJwW0jBbSEFt4UU3BZScFtIwW0hBbeFFNwWUoi3kJKbgYV4CylF17Zpiq5t0xRd26YpurZNU3Rtm6bo2jbN0MVbSCm6tk1TdK5NxVtIKTrXpuItpBSda1PxFlKKzrWpeAspQxdvIaXoXJuKt5BSdK5NxVtIKTrXpuItpBSda1PxFlKKjrVpLeIxpJwd69MdO1aoO3asUXfsWKXu2LFO3bFjpbpjx1p1x47V6o4d7FXxLFLODvaqeBgpZwd7VTyNlLODvSoeR8rZwV4VzyPl7GCvigeScnawV8UTSTk72KvikaScHexV8UxSzg72qngoKWcHe1U8lZSzg70qHkvK2cFeFc8l5exgr4oHk3J2sFfFk0k5O9ir4tGknB3sVfFsUs4O9qp4OClnB3tVPJ2Us4O9Kh5PytnBXhXPJ+XsYK+KB5RydrBXxRNKOTvYq+IRpZwd7FXxjFLODvaqeEgpZwd7VTyllLODvSoeU8rZwV4Vzynl7GCvbg8qxZE9xsjZ63CPw990Tn/M/pUntHi2p48u45kxDjzrURLo9GO7/PDYrlmfPrbb20dXZDcwewOzdzC7g9kHmH2C2ReYPZTZs7ZdLUvaq8+wS3v1GXZprz7DLu3VZ9ilvfoMu7RXn2GX9uoz7NJefYZd2qvPsIO9GmCvBtirAfZqgL26PYl0RXawVwPs1QB7NcBeDa5Xa+F6tRauV2vherUWrldr4Xq1Fq5Xa+F6tRauV2vherUWsFcr2KsV7NUK9moFe3V7F+mK7GCvVrBXK9irFezVCvaqgb1qYK8a2KsG9ur2LtIV2cFeNbBXDexVA3vVwF5tYK82sFcb2KsN7NXtXaQrsoO92sBebWCvNrBXG9irHezVDvZqB3u1g726vYt0RXawVzvYqx3s1Q72agd71cFedbBXHexVB3t1exfpiuxgrzrYqw72qoO96mCvDrBXx+t6dR4LJLuPH/0a87fGRh0mxtPEeLoYj4vxDDGeKcazxHhCi+eVGz/P84jN5yk2n6fYfJ5i83mKzecpNp+n2HyeYvN5is3nJTafl9h8XmLzeYnN5yU2n5fYfF5i83mJzeclNp+X2HwOsfkcYvM5xOZziM3nEJvPITafQ2w+h9h8DrH5HFrz2YrWfLaiNZ+tCM3n3Sc/f37/4cP7//zrw6df3n55/+nj7/eLy/1/Tv9ykcf+i08/gu5e+X84W31YeHLij7ZvX69yLF/Xvu635fQv1ORL/PIl4/Il8/Il6/IlJ7+Hlx2W7A57suT0rwbkS+rlS+zyJe3yJf3yJX75knH5knn5knX5ktOP/tp/366Ivy35/ru8jf0rcG32w7HN/f70p9/s+uNOX1/29Payp28ve/r+sqf3lz39eNnTzx94+tW+O/162dPHi57+9FvpwvYvzEebT+fI6Xew5Uvs8iXt8iX98iV++ZJx+ZJ58ZLTL2/mS+LiJadfJLS+f8LYmE+fMKdfx8uX2OVL2uVL+uVL/PIl4/IlJx99m3O/JL77rjz94km+JC5ecvoliHxJvXyJXb6kXbjkr92n/337+f3bnz+8u//J4v5P//j4y/4Hjd2nX/732/5P9j+K/Pb50y/vfv3j87v7H0qOP488xJvM37Ry+Enj4X+N+maMf97/KLz7ZMWbqLsvu/vS/wc=",
       "brillig_names": [
         "enqueue_public_function_call_internal",
         "call_private_function_internal",
@@ -1838,6 +1818,26 @@
         "directive_integer_quotient"
       ],
       "verification_key": "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"
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt/5MLGV6lakSNRRAiGRPAolZO+diNDQ/lzmDofLSbDiHPdJmc16GMYE2i4yKGuopcxgdkprtU/1G5oSvD15f0hTqg/SBRh424uOAZr1vLueNjalkZp4ZPbHE37RN86/bCfyM1N9SafkrPGy2aJZKrnwPvDH83B2wTU6LMaVLOXI70w0NEvTHw==",
+      "brillig_names": [
+        "sync_notes"
+      ]
     }
   ],
   "outputs": {
@@ -1943,11 +1943,11 @@
   "file_map": {
     "127": {
       "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_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote { let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, args_hasher.hash()); };\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 note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_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        $note_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_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 note 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 note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_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_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
+      "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_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        $note_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_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 note 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 note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_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_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
     },
     "128": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/mod.nr",
-      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\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    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\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    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, 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 note 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_notes`, `do_process_log`\n            /// and `process_private_note_log`.\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::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            ) -> pub 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::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub 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 note discovery of either private notes or partial notes.\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_plaintext: 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 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                // 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_plaintext,\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_plaintext: 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): (StructDefinition, 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    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
+      "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\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    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\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    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, 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 note 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_notes`, `do_process_log`\n            /// and `process_private_note_log`.\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::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::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub 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 note discovery of either private notes or partial notes.\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_plaintext: 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 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                // 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_plaintext,\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_plaintext: 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): (StructDefinition, 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    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
     },
     "148": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
@@ -1995,11 +1995,11 @@
     },
     "79": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "99": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
+      "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, 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\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }
 }