@aztec/protocol-contracts 0.75.0 → 0.76.0

package/artifacts/MultiCallEntrypoint.json

@@ -1,8 +1,28 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.1+4144a8dce4789d85",
+  "noir_version": "1.0.0-beta.1+3f8376928465907d",
   "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": "bY/dCoMwDIXfJde9aLop01eRIVWjFEortQ6G+O5Lxybdz004J3w55GwwULdOrXGjX6BuNrC+19F4x27bBXTBWGumNl+DTANPT36ZtUt2iTpEqFWhBJAbWJWS70djCepS7eIHRYnyDbNW1YHj+fKfr/DgFcoP/rqzvelgdGfp9fy4uj7rEu8zfdWag+9pWAOlglk3ng0WQkmO5egH",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1696,7 +1716,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "7Z3RjlNH1kbfhWsuTu2q2rsqr/Lr14gkzAgJQUTISKNo3n3cDbabbntb1qF9viX5JgrJOWZRbr7lhu7lv9/8/v7Xv/71jw+f/vn5zze//N/fbz5+/u3d1w+fP+1+9Pcb64//7c8/3n16+OGfX999+frml+Jub9+8//T7w7+G/fftm39++Pj+zS+++9cXF5t5fL/YbMzDxbOfuni28f3iuljJLy5e5zhwtHK8fPdTnry+Hy+POF492qmrq9f91a0sP1z9/2/fmN9P5szJxP1kzpzMuJ/MmZOZ95M5fTJ1uZ/MmZMp95M5czJ2P5kzJ1PvJ3PmZNr9ZM6czP018LmTub8GPncy99fA507m/hr43MncXwOfOZl2fw187mTur4HPncz9NfC5k7m/Bj53Mu1+MmdO5v4a+NzJ3F8DnzuZ+2vgcydzfw187mTur4HPnEy/vwY+dzL318DnTkb7NXCr/XgybV44GSvme5LS+sqT0X4NvOXJtNUn05a5v7gVG4eLYz7+BP21f4KTr8iat/0tT56skw9fet1fW7ofn6yTh++7Q/x+se+uPh5nXx5hQglmKMHMtTBuxw8Z7zlMmb3O/dWzP8HZfdCc+s095jz87p4vPsZ8IcMXMryR4est4W0p4yCGpc7ynKbd+CjnYTym9+U5TV9LM4800/0Cjbfl6Fi3F2fjUjRxU5qIueyvjlHiOc2QoplKNLFI0RQpGpOiWb1+bfrhxVD5Yf0eHr4rjWu4kngiXvlTgFB6oRtTCGYsSjDkF6KD/EJ0VDJ8I8N3MryT4YMMP8jwU+nVx1xuSxOHvwCwZfx4NieMOfqew0c8QX8kL1hyw5JXLHnDkndl8nn4oxqfFs/IHUseWPKBJZ9U8rJISzRHl7Zoji6t0Rxd2qM5urRIc3SsScuCVWlZsC4tC1amZeHatHBtWrg2LVybFq5NC9emhWvTwrVp4dq0cG1auDY1rk2Na1Pj2tS4NjWuTY1rU+Pa1Lg2Na5NjWvTyrVp5dq0cm1auTat2jZth78ynf0FurZNU3Rtm6bo2jZN0bVtmqJr2zRDb9o2TdG1bZqia9s0Rde2aYrOtWnj2rRxbdq4Nm1cmzauTTvXpp1r0861aefatHNt2rk27Vybdq5NO9emnWtT59rUuTZ1rk2da9Pbtk9+LjrXps61qXNt6lybOtemwbVpcG0aXJsG16brWzrboXNtGlybBtemwbVpcG06uDYdXJsOrk0H16a37Rv9XHSuTQfXpoNr08G16eDaVDuBlKNzbaodQcrRuTbVziDl6FybioeQUnSuTcVTSCk61qYm3kJK0bE2NfEWUoqOtaktWJuaeAspRcfa1MRbSCk61qYm3kLK0MVbSCk616biLaQUnWtT8RZSis61qXgLKUXn2lS8hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFJ1rU/EWUorOtal4CylF59qU20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LybgtJOO2kIzbQjJuC8m4LSTjtpCM20IybgvJuC0k47aQjNtCMm4LqXJbSJXbQqrcFlLltpDqgrVp5baQKreFVLktpMptIVVuC6lyW0iV20Kq3BZS5baQKreFVLktpMptIVVuC6lyW0iV20Kq3BZS5baQKreFVLktpMptIVVuC6lyW0iV20Kq3BZSXd9Cmkf06Z6jF29LP/5CrTxFf8BZ3zf6uTjltjjennwYRL3wxI5+eGJHlGdP7Ppm0XbolYveuOidi+5c9OCiDy76xKK3RRl9Hnzq056/1mjSNs3RpW2ao0vbNEeXtmmOLm3THF3apjm6tE1zdGmb5ujSNk3RO9emnWvTzrVp59p0fbNoO3SuTTvXpp1r0861aefa1Lk2da5NnWtT59p0fbNoO3SuTZ1rU+fa1Lk2da5Ng2vT4No0uDYNrk3XN4u2Q+faNLg2Da5Ng2vT4Np0cG06uDYdXJsOrk3XN4u2Q+fadHBtOrg2HVybDq5Np7ZNs694nto2TdG1bZqi39amEXPZXx2jxFP0R5ymhdO1cFwLJ7RwhhbOVMJpy6KFU7RwTAtHapXbIrXKbZFa5bZIrXJbpFa5LVKr3BatVS5aq1y0VrlorXLRWuWitcpFa5WL1ioXrVUuWqtctFbZtFbZtFbZtFbZtFbZtFbZtFbZtFbZtFbZtFbZtFa5aq1y1VrlqrXKVWuVq9YqV61VrlqrXLVWuWqtctVa5aa1yk1rlZvWKjetVW5aq9y0VrlprXLTWuWmtcpNa5W71ip3rVXuWqvctVa5a61y11rlrrXKXWuVu9Yqd61Vdq1Vdq1Vdq1Vdq1Vdq1Vdq1Vdq1Vdq1Vdq1Vdq1VFv9+3uSrd5v49/Om6DpfM/2Is3rte91fW7qXHMdLK/uj2V19uNj68o2mSdF0KZqbpvTL7HUePsz6E56TH/NmY+4vN5s/NuAf6QNNP9D0k0w/FjR9QdMbmr4K0/e5f+joR4xS+zf0dkt0W8rw/UkudZYXJyn9DjRZn7wN6XegydGl34EmR5d+B5ocXfr93FL0Kf1+bjm69Pu55eja7+eWfNt0m9rv55aiNy669vu5peja7+eWomu/n1uKrv1+bim69rujJuh90X531BRd+91RU3SsTfuCtWlfsDbtC9amfcHatC9Ym/YFa9O+cG1auDYtXJsWrk0L16brv0N9O3SuTQvXpoVr08K1aeHa1Lg2Na5NjWtT49p0fVlgO3SuTY1rU+Pa1Lg2Na5NK9emlWvTyrVp5dp0fRFiO3SuTSvXppVr08q1aeXatHFt2rg2bVybNq5N15c8tkPn2rRxbdq4Nm1cmzauTTvXpp1r0861aefadH2BZTt0rk0716ada9POtWnn2tS5NnWuTZ1rU+fadH05Zzt0rk2da1Pn2tS5NnWuTYNr0+DaNLg2Da5N16eJtkPn2jS4Ng2uTYNr0+DadHBtOrg2HVybDq5Nb903+pnoXJtqt5BydK5NtVtIOTrXptotpByda1NuC6lzW0id20Lq3BZS57aQOreF1LktpM5tITm3heTcFpJzW0jObSH5grWpc1tIzm0hObeF5NwWknNbSM5tITm3heTcFpJzW0jObSE5t4Xk3BaSc1tIzm0hObeF5OItpOTNwFy8hZSia9s0Rde2aYqubdMUXdumKbq2TVN0bZum6No2TdG1bZqhi7eQUnSuTcVbSCk616biLaQUnWtT8RZSis61qXgLKUXn2lS8hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFJ1rU/EWUorOtal4CylF59pUvIWUonNtKt5CStG5NhVvIaXoXJuKt5BSdK5NxVtIKTrXpuItpBSda1PxFlKKzrWpeAspRefaVLyFlKJzbSreQkrRuTYVbyGl6FybireQUnSuTcVbSCk616biLaQUnWtT8RZSis61qXgLKUXn2lS8hZSic20q3kJK0bk2FW8hpehcm4q3kFJ0rk3FW0gpOtem4i2kFB1r0xBvIaXoWJuGeAspRcfaNBasTUO8hZSiY20a4i2kFB1r0xBvIWXo4i2kFJ1rU/EWUorOtal4CylF59pUvIWUonNtKt5CStG5NuW2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2k4LaQgttCCm4LKbgtpOC2kILbQgpuCym4LaTgtpCC20IKbgspuC2ksb6FNI/o0z1HL96WfvyFWnmK/ohTtHDstjjennwYRL3wxI5+eGJHlOdPbOWiNy5656I7Fz246IOLPrHoZeGiF2X0efCpT3v+WqNI2zRHl7Zpji5t0xxd2qY5urRNc3Rpm+bo0jbN0aVtmqKbtE1zdK5NjWtT49p0fbNoO3SuTY1rU+Pa1Lg2Na5NK9emlWvTyrVp5dp0fbNoO3SuTSvXppVr08q1aeXatHFt2rg2bVybNq5N1zeLtkPn2rRxbdq4Nm1cmzauTTvXpp1r0861aefadH2zaDt0rk0716ada9POtWnn2tS5NnWuTZ1rU+fadH2zaDt0rk2da1Pn2tS5NnWuTYNr0+DaNLg2Da5N1zeLtkPn2jS4Ng2uTYNr0+DadHBtOrg2HVybDq5N1zeLtkPn2nRwbTq4Nh1cmw6uTSfXppNr08m16dS2aVYUWd8s2g5d26Yp+m1tGjGX/dUxSjxFf8QJLZyhhTOVcOaNG0AXcYoWjmnhVC2cpoXTtXCkVnkuUqs8F6lVnovWKhetVS5aq1y0VrlorXLRWuWitcpFa5WL1ioXrVUuWqtsWqtsWqtsWqtsWqtsWqtsWqtsWqtsWqtsWqtsWqtctVa5aq1y1VrlqrXKVWuVq9YqV61VrlqrXLVWuWqtctNa5aa1yk1rlZvWKjetVW5aq9y0VrlprXLTWuWmtcpda5W71ip3rVXuWqvctVa5a61y11rlrrXKXWuVu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqu9Yqh9Yqh9Yqh9Yqi38/b/LVu1P8+3lTdJ2vmX7EWb32ve6vLd1LjuOllf3R7K4+XGx9+UYTUjRDiuamb5padp9Kz8OHWX/Cc/Jj3mzM/eVm88f3WH2gHwuavqDpDU1f0fQNTd/R9C5M3+f+oaMfMUrt39Bv/L7kZfj+JJc6y4uTlH6v8ez9P+eQfq/xFH0uXPTCRTcueuWiNy56V0bPvm16TueiBxdd2qY5urRNM/SyLNI6vcAu7dML7NJCvcAubdQL7NJKvcCOdeqOHSvVHTvWqjt2rFZ37GCvFrBXC9irBezVAvbq+m8W35Ad7NUC9moBe7WAvVrAXjWwVw3sVQN71cBeXf/t/huyg71qYK8a2KsG9qqBvVrBXq1gr1awVyvYq+uDDRuyg71awV6tYK9WsFcr2KsN7NUG9moDe7WBvbo+ubEhO9irDezVBvZqA3u1gb3awV7tYK92sFc72KvroykbsoO92sFe7WCvdrBXO9irDvaqg73qYK862KvrszcbsoO96mCvOtirDvaqg70aYK8G2KsB9mqAvbo+RrQhO9irAfZqgL0aYK8G2KsD7NUB9uoAe3WAvXrbdNJPZgd7dYC9OsBe1Y4sXWAHe1U7s3SBHexV7dDSBXawV7VTSxfYwV7lxpZ27GCvcnNLO3auVwu4t1TAvaUC7i0VcG+pLFyvFnBvqYB7SwXcWyrg3lIB95YKuLdUwL2lAu4tFXBvqYB7SwXcWyrg3lIB95YKuLdUwL2lAu4tFXBvqYB7S0W8t5S8EdmOXdurObu2V3N2ba/m7Npezdm1vZqza3s1ZRfvLeXs2l7N2bW9mrODvSreW8rZwV4V7y3l7GCviveWcnawV8V7Szk72KvivaWcHexV8d5Szg72qnhvKWcHe1W8t5Szg70q3lvK2cFeFe8t5exgr4r3lnJ2sFfFe0s5O9ir4r2lnB3sVfHeUs4O9qp4bylnB3tVvLeUs4O9Kt5bytnBXhXvLeXsYK+K95ZydrBXxXtLOTvYq+K9pZwd7FXx3lLODvaqeG8pZwd7Vby3lLODvSreW8rZwV4V7y3l7GCviveWcnawV8V7Szk72KvivaWcHexV8d5Szg72qnhvKWcHe1W8t5Szg70q3lvK2bleNfHeUs7O9aqJ95Zydq5XbeF61cR7Szk716sm3lvK2bleNfHeUsou3lvK2cFeFe8t5exgr4r3lnJ2sFfFe0s5O9ir4r2lnB3sVfHeUs4O9qp4bylnB3sV3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lA/eWDNxbMnBvycC9JQP3lgzcWzJwb8nAvSUD95YM3FsycG/JwL0lW99bmkf26Z6zF29LP/5KrTxlf+Cp6xtKP5mn3JbH25OPhKgXntvRD8/tiPLsua3ru0gbslcwewOzdzC7g9kDzD7A7JPLXhZl9nkwq0+LF+zSXr3ALu3VC+zSXr3ALu3VC+zSXr3ALu3VC+zSXr3ALu3VC+zSXs3ZDexVA3vVwF41sFfXd5E2ZAd71cBeNbBXDexVA3u1gr1awV6tYK9WsFfXd5E2ZAd7tYK9WsFerWCvVrBXG9irDezVBvZqA3t1fRdpQ3awVxvYqw3s1Qb2agN7tYO92sFe7WCvdrBX13eRNmQHe7WDvdrBXu1gr3awVx3sVQd71cFedbBX13eRNmQHe9XBXnWwVx3sVQd7NcBeDbBXA+zVAHt1fRdpQ3awVwPs1QB7NcBeDbBXB9irA+zVAfbqAHt1fRdpQ3awVwfYqwPs1QH26gB7dYK9OsFenbf1asRc9lfHKPGU/RtPFeNpYjxdjMfFeEKMZ4jxTCmeduPGz2WeIsajtc9t0drntmjtc1u09rktWvvcFq19bovWPrdFbJ+L2D4XsX0uYvtcxPa5iO1zEdvnIrbPRWyfi9g+F7F9NrF9NrF9NrF9NrF9NrF9NrF9NrF9NrF9NrF9NrF9rmL7XMX2uYrtcxXb5yq2z1Vsn6vYPlexfa5i+1zF9rmJ7XMT2+cmts9NbJ+b2D43sX1uYvvcxPa5ie1zE9vnLrbPXWyfu9g+d7F97mL73MX2uYvtcxfb5y62z11sn11sn11sn11sn11sn11sn11sn11sn11sn11on3c/+PXLh48fP/zrHx8///bu64fPn/58uHl5+Mfpv4jqc/+TRz+CltofH6083njyd6zX+f3GsfQnN7aHYzn9lzr5Lf36W/z6W+L6W8b1t5x05LDDLW08v+X0H9Pnt5Trb7Hrb6nX39Kuv6Vff4tff0tcf8u4/pbTz/7YL8KY84dbXv4ur77/ivka7XBtrfXh4U//geHPe/jyug9vr/vw9XUfvr3uw/fXfXh/3YePn/jwo754+PG6Dz9f9eFP/zHSNP9+y6zxfEdO/0lPfotdf0u9/pZ2/S39+lv8+lvi6ltOv3zLb5lX33I6hmJt/wFjHs8/YE43SPJb7Ppb6vW3tOtv6dff4tffcvLZt4j9LfPF78rTEYP8lnn1Lae/ZT+/pVx/i11/S73ylv/ufvjvd18+vPv14/uHzywe/u9fn37bf6Kx++HX//yx/z/7T0X++PL5t/e///Xl/cMnJcfPRx6/sNv627ocPtN4/E9e3rrv4B6/0HrMt7PsftrdT/0/",
+      "debug_symbols": "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",
       "brillig_names": [
         "enqueue_public_function_call_internal",
         "call_private_function_internal",
@@ -1906,26 +1926,6 @@
       "brillig_names": [
         "process_log"
       ]
-    },
-    {
-      "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": "bY/dCoMwDIXfJde9aLop01eRIVWjFEortQ6G+O5Lxybdz004J3w55GwwULdOrXGjX6BuNrC+19F4x27bBXTBWGumNl+DTANPT36ZtUt2iTpEqFWhBJAbWJWS70djCepS7eIHRYnyDbNW1YHj+fKfr/DgFcoP/rqzvelgdGfp9fy4uj7rEu8zfdWag+9pWAOlglk3ng0WQkmO5egH",
-      "brillig_names": [
-        "sync_notes"
-      ]
     }
   ],
   "outputs": {
@@ -2041,19 +2041,19 @@
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note_content,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        packed_note_content,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note_content: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::unpack_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "250": {
+    "251": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "267": {
+    "268": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "284": {
+    "285": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "333": {
+    "334": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },