@aztec/accounts 0.66.0 → 0.67.1-devnet

package/artifacts/EcdsaKAccount.json

@@ -1,8 +1,134 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
+  "noir_version": "1.0.0-beta.0+4184522b3ac6c4ce82aadf4911289cdf9fb0dd79-x8664",
   "name": "EcdsaKAccount",
   "functions": [
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "11091894166229312484": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 20
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8270195893599566439": {
+            "error_kind": "string",
+            "string": "Invalid public keys hint for address"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 5,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/+1dTYgkW1aOrMys7sru6sz+73qv/173OKKgRGRE5I+4qIejo47CIKLgQozMjBweDiPOewOODFLICIIbYVQUBBciA+P4s3ExK10LojALwZ2giwGdhczChYyT0S9P5VdffnErojNudfV770J3ZMU9cf7uueeee+6NG63g/XK4+tda/+6sr/vBdjGY4/U13K1EDeIKffLZek343HtN+Gy/Jnx2GuSz4K0bnC1N89v1oNemedx/DXi88hrwePU14PEgaLb/GI82RvVW/66t/l0P3h/DtipRsMI5ttf1RUcpDLFo6EKRBwBbipyU9BfrEdKe3YP6Bh1cdEB0m8Q/CdMIZffAf3ywxnnFD/7M8F/1gz80vn/sZIMfZTG67fX1kycbXX4SnimKBVqtDcgpXqvbg7pPUF0b6n6c6jpQ9xNUhwOP8WR62wdZmrOrZOK5XVKT7QrIZno12gd+aI9aRC8INm2DdUa/F3jtA1GL6Bk/rB+zLfNn7ZMNP/tU1znZlsPqulBn7VtcnwMc29YVgPthuM823w62+4jVW7uirhu02YXh73jAvyqJ0ju3SefkLG2sQ713QJ/PST8+xiLUjw/9F/q5XcK//S7KlZPgtLRJn6gj09lVhKe6A6jrnJyl01v/3QE6iMv46BL8D63/7q+v+/CMPT8Q9PeJ/hm+xT3UEeNqi3sGX/TJj69/F/FNYT8P1sbEPrsox+tr+LIlmUdJlIXGq/mSbrDd14yu6oeN8LIuXuQk3D3gvcl4pEt6/Aq064j0h2NRc0mMcaj8TIP4E+VnmsM/Whr+rhf8aapiq+bwJ1MV3zSon1P+r/lp37Hhv+6H/9zwH/rR/6l93vCjn9P27XvBPzztvwM/+p9Z/Hcz2BSOzW/B/eb8Y5RWjc2Nfo949RWb3yJ+WD8YBxZ1twWvA1HHPuy2oHNb0FG4rjeIa3BJ+Wo3iOvaJZWxf0n5alL3ew3iOmgQV5O6b1LGGw3iajWI67Lqfr9BXKfzzWBbf0U5Xl/D3crpWGO84PypQ/IUpUvwXyY+/czzo5HKS3J84CMvWdBm3QeBjg8wH8b8nM75Rd0ui4bTaZ6nw2UWhWk8ivOkRfiNV77HfkLlAVWsoeL8BnUt812cS+xAHecgu1BnPKp8l588b1RJ/0h/IOowD1CnLW8FZ20N+6NaR+D+42k9qnJ8bfR7wbbP8xFfV80h81oKPjsQdbh+gXVIpy3ovI64eE0FdVjY6G+2z8JdA/xsfxg3voq1F6PfC3z6uI39XSd+WD9sf4eC14Go43Y+FHQOBZ0PO65+sG2HPF9TbXbdQQefN7hD8Vyr5Gp0+B7TUTz7Havf32fAuvSxXotjtY2NhW/5Otwv/tl8pRts2gafPYR6hP9ue4Pzb9b3+uL566RXP7nIMDwk/owG0u570fkwquorjX6PePXlK/vED+uH49OBH/2ELcKP/AyEfjivyW1X/LNcHdotwg9ARoTH3/Y83vv79XUgcLLt3hTyqPi/6CPfWP/uC3k4Z6DarS/wDsTzrEN8bld/qXiu0u882VXlfmf0L6rfKTt39Ts/OfFNv3PZKfJrbXlL1Bkuy7dgv0P4myAjwuNvex7vfXN9HQic3O9Ujh/vYb/7p/VvFadwv6sbp9wQPPqOU5hnZWsHApfLFrCNLVboC3r2rF+7jYZsh1jUug3yyKVNfyPfRQz7uLPBy3BME/Vk9JWeuM/cIH7K/MFAPG9wai20QZ0vVf4N48ZvkUymQ/QD+4LvLsH/B8SN/xWc1aGKBVx93mXnKo+MPuUa0UZbtmcPgm1bazpvV+C8E2wXq7sLtJFHLsrOje/Czn+whp2jnpD+eXotCrfDHQGv+q5qhzvA14vnTzZ1p3u71tcO1DUZYxS6G3W0forSPbkY/QwIHnWl4rNboB/uWw3GPENf/dP4/bD0z8c79k+lJ4TDOuOH7/E4pOK688aJWy1Ns+448Y8wTtxtlcvI+QU/+13C2NVfXXZ+V8BjHzZ+TTa05bsk210vsm3WCe8F28Xq7gNt5JGLsnPju+44hHpC+ufptSjcDvcEPOqTxyGU8R7w9eL5k00dxsRF6UCd73EI5eVxyJd+BgSPulLzFaOp5l99qlPzqRbVIX+uGFrNmRSdOzvSuSPo+I3Vw8Tlz+uOuTcdesJ4guc7KsfbEjy4+FJtdeCgc2dHOncEHc9z2ZTjBCzsd1EXyu/eoboHUMd5vyOoa1HdG1DH62Vvkh6w7iHU4Xo7l/Pm3D9TYwzA9jc9eY77arcZ6xfbDPnncl5M+Ly7wctwzA/a7z2quy2e9RtTvB8vMa8qN2v0e4HPNt3kZtW4qPaXqXa2Z9UYWGU8vSfoKFzWlv1gu414f6CS566DTpX4sijH62u4W4lVbMk2iP2l6bkp0jMd4T2k3wu228KHDd4nfspsQ/l5e3Yg6u5eiF6jCfOFRY0/7I9w/Kk7lzCZCv/4UzX8I/Yh480153LFTK79qKqvXrb2QB65nKfzWQ2do16Nvs3zbb/dl9YPvtj31Dr7POYJbL9Jce9X10xeNr1y7IZ2zrEbxlkcu2GcxbHFI6hjP/GY9IB1T6CubuyG7V8ndlN9zu++tWjMMVgg+EKfyfrdpZ+YTHVjNxyTHlBdSzzree9f5diN9/61/PDj3PuHPHJ/uCN4VXPBKjl5lTtRuExP/RLc+HtP0Nlz0GkJnhWdezvSUXGt53cVavdbjinUfLdqv7V7dWMK1Lnx1g/K26oVbNusy44HQbkNeW6P2msfyCOX83ReJ6ZAvd6luj3xrOezNPKqvtLu9YJtffnwlW3ip6zPF37R4obP5O99+guzz74z/1T+xXff/tzi09nn33sn++zbi8Xn83ffZe+FEQZLy1bAMPa7L+4HwaYXoSb3SuijhG0hoepFbcKlRhalLdcIgaNxzyHHnQq4XLTPW1HinQ3I190KuFy0z1sl4FVb5OsePYejDMKV4eYMQhk/Lv5dM+/i9y0H//cr4HLRfiDgESdn35GvB55pHxLtG4K2i2duN+zvitcbgjZ7bE9ZoZHp5Ejw5dLhGwL+SMjZD7bb7I2LkW3s4tUl25sC/g2HbCj3mxcj28TFq0u2hwL+TYdsKPdDx3MIhzD3hW5QP2/40c/UJa9LP48E/EMhZ1/o4NHFyJa5eHXJ9ljAP3LIhnI/vhjZZi5eXbI9EfCPHbKh3E8czyEcwrwhdIP6eeRHP3OXvC79PBXwT4ScfaEDe7bKzOKJH7kXLaJncuA9pH9RM4uq7XBIusRnB6KOY/Kngs5TQUfhut4grrsN4rrTIK57DeI6bBDXgwZxHTWI636DuN5sENfDBnFxnIkZleP1NdypxInK1LWILtrAq8i2GP1esN32Pnyia35VFM6iHvnhZ9Ei/MjPkdCPWqni/mu2jjt4Ef4IZOS+gfFvl+49XitlIHCyP1LzGbxn+i1WBx+s/+gLXOwD6r4Br+bMh+K5VsnV6PA9pqN4Njp4UgnuvP74XnBGNnsO2w2ffQT1CP+37Q3OHyBd4vPGY4O+ZsE3DDfvSntJ/FQ2bz1hTBOQvp8KmVsCXmW5je8iy/1XNbLcaGdPqQ7751tUh338GdVh/3q+/v1B6yN9wUOV3Nl9Bx21+8Y1Br6sPIpntQNhVzoozxHROWqQDtoixyWe5tILtTKHPvKnyUeqsW1P8M1j1x+Bj/zZvbOyPfQi28v7Kqt7C+rYjp9BHdvec6jDNuWi/J/povB//1LD/6G/f0p1yod4zj1W3hHBOwkP/fDj3EmofHPdnYQ8v1Hx7QNBR+HiPBryfNyMPpYuP+k55q68y9To94SOfNiGmgOoNlN9zp4diLr7F6LXaMZ8YVE75dhvYT6ybtxmMtXdEYL+x3i7qBjL79y7fnsgj1yUzo3vujtCUK8PSReXxTZ3sb9v72h/yvfzuk3zeaLNSWdH5+MezpdRnObjNBxlSboYxcPFcBwuknQZRZNoOE0mcbycJ5PFZBgvh+PhXOmf/b2fOOz9t++QXhBof2/0e8G2D/Xh713rnEVhf/9I8DoI3L4T65DOI0FH4TpqEFeH5HHFhZ7G/spxIY/9vuNCNfa74sKHgtdB4PbpZTb3UNBRuHi8fgX55Mp9+TLkk1Vfvgj7LmvnQwc/ntaCT08bUWvlKodTvEm3H2zbEOoLbRL5fgz4i3JRcZzLBpSMrj6PMvccchxVwOWirfbkIE7ek+iaa75Zk/Z5+3t4T6Jqe6bDcAiDJ+m4cokMG4j7llfCtrhDsPzmlNoFz7rbK+GB12qU30d8R+fgY/09FHCI8xH9rWJ3HpOsvijmX/hNp+P13+FupfJ4YPR7Qm4f44Hyd2qcLfzdlWDbl6HNYPup/bnF7xtCVvaDKn5sBdvtXCWuK/PBdWQ3+PP2RfUccjypgMtF+6mAR5zsB117jpT9V7FP5EvljHfF9bQBXK52HwTbentMdU+hjk8vfUvwZ34D89yvwm8Y/R7x6stvPCN+WD/Kb6BPVvniqjDPgG5R+sF2G6D8Zfw+E/wOxPPPCNfzoJrsBv8xAY9rHz2HHB+rgMtF+/sEPOJkv4F82bO8RvWfayJF/Pvv699qfcz6ndpf8JjqcN3O+t2L00Ed+J858D934O8I/MpvsE2g3+hS3VOo47U9s91vg97+x0H3joPuPQfdG8E2fj5d/zvAw/86eDh08PDAwcP9YBu/xYQdAYf1XSGL/Y08oQ0gTv6SYkfAHwkZ1R4UV46dx/KBoFP2Lgv+fbVEDsOn2oXt7omQx2UbTM/soy9o8Bee99sbvv8PcscIYziKor7S+yrGRv7al6evw5+OjV3ih/XDcc+h4FXtReF9zHVzAojreoO4+HQYXHc4Xl/DeiXmG36/tFH/rWQVg6L+sCDfdfdrYd/ht5KxDfmtddc+P/UOnnqflP1pm2Tke2wjri+f4XOtkmsQVIv1Fc/Kp7PNq37addC5Lugciud2lUfxzG3eBB2U56L20/HXPcr2U4XtzX2sK9tPhV9tQfgvwX6qeP3bfImfceDlfYnVYb6E7QzjCrYNnC/VXRc2XdTdT4VtwP5J9XG/uq/+dUOj3wu2fYiPmKBD/JT5zqJNrY0/k7/3qfyLv5B99p1F9t47v/a5n8t//Qv5u++hGIi6I8Tk5ueQ2OD476sCLiCYOmJVCY2wG6vDZ7grvALzil9381JhhT2rhh+2pbpDJuLipTzU4XEj+ohTdktBcGG2MXxZ29jzw4/TNlA/u9rGZRtOWR4+dDMIgpcaFuts18P25g8psE/E33vET1lbuQ7uumwHOKl+gTJiQb7rbtdzhSJ44KPB4YGP3G5I46MPMm9sEXnkftYWvKopGh5cjXVIxzWtRFy3G8R1s0Fc/PH5qh9kxja1Z4oUPU9rfgumNb9P0xpPHwc43bJjqYyyqRh/eMXgfxvSh//fPasP9XEElTJjHhAe5Tb4PukNn/X84bNLNQ20Okx/1z2sFdPWe/sbvAxnBW2zRTSNBtsOf+AZlzQUPKYFEP4PwNbeBl7LnseUAy93/TH0ta9RX/O0PeP0dWt8lVbJ/5DkN/g/dfQ1ta1JxfDMA8KrZbIqx/h8GF5hszpcZkWdcFF9DV9vq9rXvkZ9zXWcleprDwGXgsdXGhH+ryv2tTcBv70uqV6rrbJdseuQ40jIgfAPSA6D/zshh+fXSufcVmWv1Je9LvoNRz9v+qg2Tq27jmrz9ErCgm0V9aW2frKt/oPQl9kbfnwLX0UrSufEizy5+vgWtlsX6J7XRkXhNj1vCysv5bu262O/NJoqZ2A48egI1wf2jFf1QQSct3E/vwN0FDx+UBrh/9nRz/18tGbzwex7wFOb+ET6XYL/pqOfq6NWXR8GPe+oVf4gl9rKeUB/+9KXOmpkX/DDW23+rWI/f5Uf2cN2437uaqOicJued/ys6Uy9HsDbjdSxviqPYnaCH+dU/bzKB5dd/RzpKHhe+jP4bzn6OR+sf7z+O9ypbOwW+zH3SaTfJfj/dvRzdZwzboVnm7j8Hwh1+8V9wQ/7xe+8Bv38Ij+myf3c9TFN7Jf8ERnVv/Bj7a4Pa3r+MHRqulAfAMbcIr8KY/DtdfuoPob9ie2wKNwe6kOZKDd/dBJ1fpP05edDkRt93TpHXzdJXwbfE/pSfQw/UlqUzokXeUaqj2G7cR9ztVFRuE3V+IRtY/Kpj1nzWKfymqhzHuvs+f0S+LLc6l1oIxvr1HjOrzQo3MXjX1//9tmW40kYtkw3Jxu5OB+C9LsE/2gtN+cyi2tnBz6X4yxaxtkyS7PFIplntwh/UcxuijYs9P6gs9FZK/C0XhRttkLyfo9G8K9Klf0Vfrb0DqMW0QsCvRbGW3r9rHW6t/SqtSDTz74f/YSFH3Kt/XLbIB98rEGLeCzKR7b8kS1/kGz5dDw92ciHMUtRrqz/7sCzCG/8dAn+R9ZMFHz9KMQjL2AFvQLuUw64Vsn1BQ5xr3Ny9t7ByTZ8+2Qb3mj3TrZ5tLprUIfxVFGur/9GfSEu46NL8D+5lv10Kzw8Y88PBP2rRP8M3+Ie2g/jaot7uB/kbYonUPam++ILmoQf7zFvZjvsozmWM3zqijpQsYz1eVynPW5G5nAQbMecRsdkuNaADINgO7ZmOr0G6PDHMotyvL6Gu5VoQHwiHabbtF/mo7uaxR8tPe9TifhVocbaJdrEE/jqHs6bfrmzuY/jFM65r4o25VftvgtjS0Y41fit7NPuXxHw6rjtfrAdi10poYNw5/G2d0G87ZXwpp7lvIxaTz4QPB6vr2E2mY+H+ShchKv/luliEiZpMl0kk2UcJskiHEVJOJtO8sU4GmfTWRoPs+UoDudRGofj6amNXhW4h8s4Tob5dLU8OJknk0k2nEzjKMvy0WQ6DsfxZLmYjybZcpEPp1G4yMezeBjOV4vJ01XnnYwXB8H2eGC4oziJFqNxuszCOMzneRxFcbZI43kWJ8tFFM+i6WyUT8ejYZiMxqt7SZRMhsk8WYyyRR6nrvFhOBmm8/F0Ph9l6Xw2y/PlePXUZBnNRlk0nMXRMMvieJIkYZYv81kST1dKmswn0ygZz8NkehBsjwGGe6XU4SgfJVmer/ieTifzKJ5P5nk+X2RxNl6lEsaLWb6SZDibr/Q3W4Z5lk/SaJbMxtFK605fnUTDYbxiYjaahJM0XMwnw3ySpWk2TYeLZLEchsN0tMzDdBovpsl0dTuJ5tkqSRBms2WUOo86nI7jWTicp/Msm8fxNM+TFZOLbJZG8XA6Ha4SDbMXCgrHebS6naeL5WgcrmwnDsPpaMi+8gzufDGLVjYQz+N5Po1my5US89XPLFvJsCKZRMtsuginUWGpsySM8+Usmi+z4XwWx+l4qV6pPIN/x8J54DN2OFtO08nKjuP5LJwu0ukwDkdhnIXD0XTVcKPFaDkdJtNkkQ2TZGXlcRotV6Y6LBpjJeeEc6Zn9RIussVwmIbpJF4Os+mqnVZUknyRL5bROIxmk3QWxiu9Zfk4jZf5SvXJbNXPlpNoPktPdX5L8T2czlb9ZJGlK8MKR8PFaJYmyQpDPJpNV31zFKfhcrScZeHKpla9t9B9OJ2m4XSZrijnhvu2wh3FUbqyhNFkuVJFOIyHyapPj2ZJQW2cjEYrE49nk3EUzdPhCvGqY666VJTO5mGc5NlIrTfwXNfPOk5U+b0Yo98jXn3E10jP+GH9uN4VsGfVWgrnbdW6zD1Bx7Uu0wSufoO4eg3iunVJZbzRIK6DSyrjzQZxHV5SGa82iGtwSWW83iCuKx5k5Liz4TEmVftmrCj/zTnlgGTEgnwXtvSJCntu1bsdfAwD2iUfb4/+9VXqSY3dVpSejO+6esL2YD2hzbCecKx9lXrCOSIXpSfju66esD1YT2gzrCc/+aD6euL8KxalJ+O7rp6wPVhPaDOsJ095rdp6UrlFK0pPxnddPWF7sJ7QZlhPnt6Lqq0nXPfhovSE7ynV0RO2R53jdPYFXs85zsqf8DX6vWBblz7mW2q/i9o/ZbrrC17V/jSOV9T7f31BR+G62iCuToO4DhrE1WoQV69BXN0GcV1rENdeg7iuN4ir3SAufucNfQf7LS/7PWoc2Wf0X+W77ipP5PlshdPPEKgzO/Yd/Hg6YvH0/TS1TtMS/OBnEdiGgmDbZyLfuJ6DsnmyxdClayVbi3hGeJTJ4F1H6p23b6Ul8BotjEWulvCG+0cR5nTfCcHvrX8UsL9I70pcIR6O13+HO5XN3n/cp630eYV4Pj0eGHjmfdxV7ZV5QHiU2/hR64UDx3NoK+pZXofE3BPvUbgJvDOdAcFeob+7Ao/aj2HPXVTbqz38rrY3+Ns12961Bq32h1dt+5v0nPJtZc/yXpcrwB/j4vbltXflR9U+mE4Jnr1g2/76hKcnnnP5ULVHoqqf4uOJDf4taHd+11w9j3sy1J4p177Qj86Q0/tCP9hnyIUJ502C4MJs46Mz5PzIkTJfWNQ7bywPj4NBcLaNUDdYUKZdzpAz3j4YZ8ht+hjaFctf5kO4KJ3bvV3OkHPF6gZX9r6EJ72FLh+K8rB97At4njMWRe2V2ydcdff41aWt7N6zXiMXr3X3L3KOFWVTcVqV8cZXP6w63ti9ixpv2kKvrvFG6Xwg6jhuVe2t8iwKV6tBXE34mqIcr69hvVL6uQWMqRts56l6ZyEgHfD6uP3movy/8V33cwtoH/zOgJq7Kfvj8/gwduD9zGV5sbI+oOLxgXi+TTyoeU6Vvq/oKJ7VuMHjt4ohOw46KoZUccOu8iieVby4Kx31LptrDfFl6aAtXkw+J4w9+4vQ796iMFLxn8lS6PN3KMdkdWXnMnLeyuC/0t3g/N3u2bbxNKaO2Q9hOSxpN6xDnXM/RB/NfQfzTnXX8E0XdT9HgX3GZMLzc+3eH0I7fJXawc++rM35uaaXMtvhM00N/k8cOU91rqryEcwDwqPcvIaB9sHvx3jS10y9E2hF7V9hu8V1ErZbzEey3eKaKftpzI+iTrgom8Z9c1XP9Pxqid8xGmw7vIcAz7dV8OjHEP4vHXnW83yk6/yAohyvr+GO5RXmcCvPmz4oOdwqa6B1c7hN4nLFhZ7XyCuf38/nPFy2zxCq+aiKKavkd6rOey8rLrYdbEcfcS3yHgTN+0hXn1FyK19fNgdTYyjrC+uwbxhtzm2ofJnRU+eSNKkz49/i5bI5rdHvEvy/Ujzpa07EZ1IhLc8+b6TmrVZU3oPtCnXC9shzPKwrW4PmouIv00VB+5cqxF/KBltUp/yP1ak1I7Xmwr4W+xyf54h9h+f2PA4dr6/hbiVSeZKL8o8tkjsI3L68Shyk2tHl51C2slysi4bhVPG3a+2q5aDf4Pp3xDdYDy7Z1HpOp0RufL4r5C7LF7KeFG+qjzLePYcc5z2r/JSymcIumj6LcDycp1mcTsN5no6z0fi8swibpp9PilMElnkWRdFwEeZ1zkJUfpLXxNReKzV2BkHzfuX0fEugg/zw/Njge7RH0lMORI7xPdKRr5xui3SAfdmVY/b1jgnn8L5/Tai49Ne/lU2xr1exh9Wp2EN9Q4rt1M+7d5s2wH27bcErnyNk8PfXejnv7F5sw6J0TrzIk6izezG/1wW6KFcQbORGeB73DwU8tg2f3Ys5Qh5D1PwZdc7zJtNh2dm9ho/nC8+gjfjsXuz314h3lYdzfRJdxXGYHzy+kH3f4YTnAFjUHKBFdSpPrdYceO6AdlB37mC6qDt3aMIPsa/xNdZ8mP2C6dTlF5rskzyvU2eTYZ/0EdclaTaeZ+MomiZRnkTpy5xxfVn2a7YE71ZUf8Y9md+mcTEQuFTMz2tDrrk5zkeP19dzdBCdpySjxfObKvOmQMjDex14vGoJPLw//+dpDPEUC8q4mNujJeRU7Wg68tHHhpPJaDqchcl4MV8ukvhl+pgvHXoe5yPP+c9Y5bZNV8X1V/Y397EOY2h8lud6Bv8bMM+Y0zyjydygigt47Pe0/yXh2CoAefyew1J9/czo9wKvcdDp+pnaI+F6B9fTHDBxxTA9wU/xTtqNYLvNkD/D5ToTFe2XzwCou7aGz3Psg23syoVzjKbGWxVP4T4gVz6qRXoo8xO87mPwXwI/8WfkJ1SsomJ99hNqD6zVqff6/J5xs7HFG+foiN8zNvgvi3yEy75xfzDH9OqsERW3m77Q/m+Qvl7FN9O7gp8uwf+eQ19Vz1phHhD+hkNfqEt8lmmX+ZaLssXzdMu2aPBfqZgbOwB5itI58SJPqubAOM/tAt2y/oLwVdrfNc91nc2DPpv9OdK9TnXoa9mfo88234a+1DX2qPdq2J/vB/X8+Z+LvFzVmPN7VoIVfZofAQA=",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
+    {
+      "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/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgFAXQf3nrFmla2a/EEFYWgmiYDQzRv49FMzRDG908vOJ5bu4KvWiXsZF6MDNU9QrKdNxJo31atwRaK5WSY3O9hnQfCB3v54nrPc6OWwcVzrIEhO79iSDvB6kEVCTF2yMBhMNJFk5IOKHBBN/+wghip2GE5F+EaHogGoPyGFTEoDICZbc9YDQtP4ji4hdtPj65lbxV4uzZsOjuUjv3msRfAydrOtEvVuxdvNTQzxoVCcZ+rV/9Bg==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "verify_private_authwit",
       "is_unconstrained": false,
@@ -164,7 +290,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -402,7 +528,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -495,6 +621,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -1263,7 +1410,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -1501,7 +1648,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -1594,6 +1741,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -1612,8 +1780,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "7V3bruS2sf0XP88DWTeS+ZUgCJzEJzBg2IHjHOAg8L8f7fG0uj1qSZ4aNbVqiy/BnlhLtVQsFouUVvV/v/nHd3/7zz//+v2P//PTv7/505//+80PP/3921++/+nH6V///SbTx//v3//69se3f/77l29//uWbP2Vr6cM33/34j+nPktKvH775n+9/+O6bP0miXz8srqbK9dPVVO1+dVZ7cjVrbp+uZm20c3U20ZmKicl8PVV5dn2pfLu8pvvd6enNE9nt4lT08eK/fPgm83DNmmtkuGbNNTpcs+Ya+3rXSFL9dLWkluerW/1oobzcQv1SC2+g9gzEevOVUNr2K1G7DTFx3hsEnuMhM1f3iC0vrppvsVBV007kVJL5anpw5EqcNaIbkaa0N0PuV3NqZb6auT27OhWbJ1Rqye7Xi74NEKUxQNgDlMcAYQ8Qfe0AldmNVGTn4qMWpSsNEI8Bwh4gGQOEPUDPK/svosRZy41SbrxHKTe5MSLKu49b74+b76tWKc+IkOTbxVPg3DcN6WOZS3ahZy0XetZ6oWdt13lWThd61nyhZ6ULPStf6FnlQs96obqJL1Q38YXqJr5Q3cQXqpvkQnWTXKhukgvVTXKhuknkQs96obpJLlQ3yYXqJrlQ3SQXqpv0QnWTXqhu0gvVTXqhuknlQs96obpJL1Q36YXqJr1Q3aQXqpvsQnWTXahusgvVTXahusnkQs96obrJLlQ32YXqJrtQ3WQXqpvKheqmcqG6qVyobioXqpuKXOhZL1Q3lQvVTeVCdVO5UN1ULlQ31QvVTfVCdVO9UN1UL1Q3VbnQs16obqoXqpvqheqmeqG6qV6obmoXqpvau6qbRO/NkB403G/Purw6m80q+JLKwjPvqsr6Ms+UB8+0uvDMu6rJVGz2TN31TMr3ZggPzWFy1idXSyq3zlCS06NL+OlMZbvP1DZfPT3vm9NlOP0VTme5PeTkBfvc6e+qSn2l0/N8tWSpXxfp76pcxnH6dqS/q7r9pU43mp3e5Osi/V1tIHCcvh3p72on80qnU7q1RBKS9FWRntO72lPheH0z1CfLw+t/0Osqs9cf7u2L9Xe1c8Tx+k6sj13pH/M6t/newtb2vF5sdknNd5fk8pvX5bpeJ577PpPQ77z+0TUX3jzuuebCW7w915TRCfTYTqBRA0Xmq/PvjmyfJnXKc0lC9OCSNwd+DKs6wmqE1fFh1UZYjbA6PKxyGmE1wurtIbnOP8agueyEVW5lHvX0cCA+h1UeYTXC6viwel/nPW2+2KjsOLIVvl3ditzPEtqzi4m43mnLw2HCp59Xyu/rCOdER0p3Rz7+xM7D077d+yOj/ochMm+0aSpOlowMjlGBY1ThGDU0RpTgGGU4RgTHiOEYCRwjuJxNcDmb4HI2weVsgsvZDJezGS5nM1zOZriczXA5m+FyNsPlbIbL2QyXsxkuZwtczha4nC1wOVvgcrbA5WyBy9kCl7MFLmcLXM4WuJytcDlb4XK2wuVshcvZCpezFS5nK1zOVricrXA5W+FytsHlbIPL2QaXsw0uZxtczja4nG1wOdvgcrbB5WyDy9kFLmcXuJxd4HJ2gcvZBS5nF7icXeBydoHL2QUuZxe4nF3hcnaFy9kVLmdXuJxd4XJ2hcvZFS5nV7icXeFydoXL2Q0uZze4nN3gcnaDy9kNLmc3uJzd4HJ2g8vZDS5nN7ScTQktZ1NCy9mU0HI2JbScTQktZ1NCy9mU0HI2JbScTQktZ1OCy9kZLmdnuJyd4XJ2hsvZGS5nw+kgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLgdJAEp4MkOB0kwekgCU4HSXA6SILTQRKcDpLhdJAMp4NkOB0kw+kgOaHlbIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HyXA6SIbTQTKcDpLhdJAMp4NkOB0kw+kgGU4HKXA6SIHTQQqcDlLgdJCS0HK2wOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4MUOB2kwOkgBU4HKXA6SIHTQQqcDlLgdJACp4NUOB2kwukgFU4HqXA6SE1oOVvhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQSqcDlLhdJAKp4NUOB2kwukgFU4HqXA6SIXTQRqcDtLgdJAGp4M0OB2kJbScbXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgDU4HaXA6SIPTQRqcDtLgdJAGp4M0OB2kwekgC5wOssDpIAucDrLA6SBLQsvZBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kAVOB1ngdJAFTgdZ4HSQBU4HWeB0kOUEHaSV273JmuzcW2i+t1C53zs/u7VKsk8Xq5A8XvzxWe1Cz1ou9Kz1Qs/arvOsJyhZz3vWfKFnpQs9K1/oWeVCz3qhuskuVDfZheomu1DdZBeqm8qF6qZyobqpXKhuKheqm05Q7Z/3rBeqm8qF6qZyobqpXKhuKheqm+qF6qZ6obqpXqhuqheqm07onHHes16obqoXqpvqheqmeqG6qaLXTZbk9qxG6XP6Db0U2qGPXt3s0EcvWHboo9cgpjrTL0v6Eps+eqWwQx998d+hj76e79BHX6J3Mk/oVbem0KtuTaFX3ZrgV92tqVtT6FW3ptCrbk2hV92aQq+6NYVedWuCX3W36cOvupv0M/yqu00fftXdph96r1sz/Kq7TR9+1d2mD7/qbtOPverm2Ktujr3q5tirLsVedSn2qkux97oUe697QousQ+nH3usS/Kq7WTQQ/Kq7TT/0CXOl2CfMHHvV5dirLsdedTn2qntCk7ND6cdedTn2Xpdj73U59l6XY+91JfZ7XYn9XldinzBL7BPmE9rUHTp1Y6+6EnvVldirrsRedSX2qqux97oae6+rsfe6Gnuve0KjwSOLBviuhDv0Y58ww/cO3KEfe9WF7/C3TR++ad8O/dirLnxrvR36sVdd+AZ4O/Rj73Xh29Tt0I+914VvJrddNMD3h9umD9/ybYd+7BNm+MZs21MXvtfaDv3Yqy58R7Qd+rFXXfi+ZTv0Y+914buLbdOHbxi2Qz/2Xhe+rdd20QDfqWuHPvyqu00/9gkzfIusnakbe9WFb2S1Qz/2qovfm2qbfuxVF7831Tb92Hvd2L2pauzeVBW/N9Vm0YDfm2qbfuwT5ti9qRp+b6qtqdvwe1Nt0w+96rbYvalaCr3qtti9qVrs3lQtdm+qFrs3VYvdm6rh96baLBrwe1Nt0w99wtxi96Zq+L2ptqdu7FU3dm+qFrs3VYvdm6rF7k3VYvemarF7U7XYvala7N5UDb831WbRgN+bapt+6BPmFrs3VcPvTbU9dWOvurF7U7XYvala7N5ULXZvqha7N1WL3Zuqxe5N1WL3pmr4vak2iwb83lSb9GP3pmqxe1M1/N5Um1MXvzfVNv3Yq27s3lQtdm+qFrs3VYvdm6rF7k3VYvemarF7UzX83lSbRQN+b6pt+vCr7jb92CfM+L2ptqdu7FU3dm+qFrs3VYvdm6rF7k3VYvemarF7U7XYvala7N5UDb831WbRgN+bapt+7BPm2L2pGn5vqs2pi9+bapt+7FU3dm+qFrs3VYvdm6rF7k3VYvemarF7U7XYvakafm+qzaIBvzfVNv3YJ8yxe1M1/N5U21M39qobuzdVi92bqsXuTdVi96ZqsXtTtdi9qVrs3lQtdm+qht+barNowO9NtU0/9glz7N5UDb831fbUDb3q5hS7OdXEP/S6O/EPvfBO/EOvvBN/+KV3h3/oHe/EP/SWd+Ifes878Q/9gnfiH/oNb06x21RN/EOfNk/8g6+/+J2qdvgHX39j96qa+Adff2N3q5r4h97+TvyD739jN6ya+Aff/+K3rNquH/B7Vu3wh19/d/iHPnue+Adff/H7Vu3wD77+xu5clVPs1lUT/+Drb+zmVRP/4Pvf2O2rJv7B97/4Day26wf8DlY7/IOfP8fuYZUTfhOr7fmL38Vqh3/w9Td2H6uJf/D1N3Ynq4l/8P1v7F5WE//g+9/Y3axywm9ntV0/4Pez2uEf/Pw5dkeriX/w9Re/p9UO/+Drb+yuVhP/4Otv7L5WOcVubDXxD77/jd3aauIffP+L39xqu37A7261wz/4+XPs/lYT/+DrL36Hq23+sVtcTfyDr7+xm1xN/IOvv7HbXE38g+9/Yze6mvgH3//it7rarh/we11t84/d7GriH/z8Gb/d1fb8xe93tcM/+Pobu+PVxD/4+hu759XEP/j+N3bXq5xit72a+Aff/+I3vtquH/A7X+3wh19/d/gHP3/Gb361M3+Dr7+x219N/GOvvzl4/6scvP9VDt7/Kgfvf5UT/Pq7wz/2/jfj97/arB8yfv+rHf6xz59z8P5XGb//1fb8xe9/tcM/+PobvP9VDt7/Kgfvf5WD97/Kwftf5eD9r3Lw/lcZv//Vdv2A3/9qh3/s8+ccvP9Vxu9/tTN/g6+/wftf5eD9r3Lw/lc5eP+rHLz/VQ7e/yoH73+Vg/e/yvj9r7brB/z+Vzv8g58/B+9/lfH7X+3M3+Drb/D+Vzl4/6scvP9VDt7/Kgfvf5WD97/Kwftf5eD9rzJ+/6vt+gG//9U2/+D9r3Lw/lcZv//V9vzF73+1wz/4+hu8/1UO3v8qB+9/lYP3v8rB+1/l4P2vcvD+Vxm//9V2/YDf/2qHP/z6u8M/+Pkzfv+rnfkbfP0N3v8qB+9/lYP3v8rB+1/l4P2vcvD+Vzl4/6scvP9Vxu9/tV0/4Pe/2uEf/Pw5eP+rjN//anv+4ve/2uEffP0N3v8qB+9/lYP3v8rB+1/l4P2vcvD+Vzl4/6uM3/9qu37A73+1wz/4+TN+/6ud+Idff3f8H/z8Gb//1Q7/4Osvfv+rHf/H3v8Sfv+rHf6x118K3v+Kgve/ogS//u7wj73/Jfz+Vzv8Y6+/hN//aod/7P0vwfe/KjXf+JfKS/7P198625hOKMqMovKMfkn1Rr8ob1/8Us8Uvl1NpezdO99HNpvVR9q/eYaGZ1Y8w8MzK56R4ZkVz+jwzIpnbHhmxTNleGbFM3V4ZsUzbXjmuWdWOsUNzxAdUAO3fDsm4lby9sW11Pbp4lrz+3EjDTce4Ubu7EYju7nRxHbcKDqngOlvknfjdRleP8HrOlLGEW604cYj3FhGDjjB63V4/QSvt5EyDnAjp+HGI9zYewcmdnsrUqWld+PGsQM7xI083HiEG2Us7Cd4XYfXT/D62IEd4sYy3HiEG8eW6gyvt+H1/l6XsQM7xI3jHdghbqSxkT3CjWMHdogbZbjxCDeOLdUZXrfh9RO8PnZgh7ixDjce4caxpTrB65qG10/w+tiBHeLG8Q7sEDfy2Mge4UYZ0XiEG8d3goe4cWypzvD6+KzwDK+PHdghbhzfCR7hRhtbqjO8nofXT/D62IEd4sbxDuwQN8rYyB7hxrEDO8SN4zvBQ9w4tlRneH18VniG18cO7Ag3lvGd4CFuHFuqM7xOw+sneH3swA5xoww3HuFGHRvZI9xoIxqPcOP4TvAQN44t1RleH58VnuD1OnZgh7hxfCd4iBvHluoMr4/mhmd4XUbKOMKN4x3YIW60sZE9wo1jB3aIG8d3goe4cWypTvB6G58VnuH1sQM7xI3jO8FD3Di2VGd4XYbXT/D62IEd4sbxDuwQN5axkT3CjWMHdogbx3eCB7iR09hSneH18VnhGV4fO7BD3Di+EzzEjTJywAleH80Nz/D62IEd4sbxDuwQN9axkT3CjV+/A5NU06eLZdrSbV/cKN34NPo9nyfkk/LN6dPf0t6L13MaXj/B63l4/QSv0/D6CV7n4fUTvC7D6yd4XYfXT/C6Da+f4PWv3z0q2e00Q5nqu/FMHZ5Z8UwbnnnuGUrDMyueycMzK56h4ZkVz/DwzIpnZHhmxTM6PLPiGRueWfHMqIHXPHNADczltidTYd3xTJkG43brwnV3VzZVXPOujPXdvEWhNvx+ht85Db+f4vccyu/2bvxO4H5/p6duzMPvp/hdht9P8bsOv5/idxt+P8XvpbffRW32u9LOt2f5jfTt8lxSfjd+r+B+L01mv1d6P35vw+9n+F3S8Pspfs/D76f4nYbfT/E7D7+f4ncZfj/F7zr8forfu+9Xpw3r7Pdi9G4cWYYjj3Fk9x1lbXdHtvxu1J5ywBZRpM6OLHtnS3U6gJpvTendnC1pGo48xpF5OPIYR9Jw5DGO5OHIYxwpw5HHOFKHI49xpA1HHuPIMhx5jCPrcOQxjuy+s+F0vzXzTgsWodk1Mj34fHFuT4mk+TtmeWg19PTiOENkaQwR+hDlMUToQ0RjiNCHiMcQoQ+RjCFCHyIdQ4Q+RDaGCH2Iyhgi9CGqY4jQh2icLqAPURmnC/BDNE4X4IdonC7AD9E4XYAfIhlDhD5E43QBfojG6QL8EI3TBfghGqcL8EM0ThfQh6iO0wX4IRqnC/BDNE4X4IdonC7AD5GMIUIfonG6AD9E43QBfojG6QL8EI3TBfghGqcL6EPUxukC/BCN0wX4IRqnC/BDNE4X4IdIxhChD9E4XYAfonG6AD9E43QBfojG6QL8EI3TBfAhkjROF+CHaJwuwA/ROF2AH6JxugA/RDKGCH2IxukC/BCN0wX4IXp+uvBS/vV2b2osv7v3b5TqsZTo4SfL3ij9ZuT5ftDa/NOtJaUdIyXTrUdhyXr3bavP4qfd4tgeHjqL/vqX6V9/+/n7H374/p9//eGnv3/7y/c//fjvN2R6+5/nv3ZbhG6/hVce28Tn9Mw21dvF/OALzW+ueP6rrgfen198f3nx/fXF97cX37+8+P71xfdvr73/819FO/D+L56/8uL5Ky+ev/Li+Ssvnr/yxfP3DVQ8oOoBNQdIkweUPSDygNgDEg9IPSBPRKgnItQTEeqJCPNEhHkiwjwRYZ6IME9EmCcizBMR5okI80SEeSKieCKieCKieCKirETE/FPG059tARIPSD0g84CKB1Q9oOYA1eQBZQ+IPCBPRFRPRFRPRFRPRFRPRFRPRFRPRDz/XrhYuh1JTH/aApQ9IPKA2AMSD0g9IPOAigdUPaDmAOWUXKjsQpELxS7U87BQaTdULbazzfjd1U2XNrSDDetgo3SwUTvYaK+3kdPX25Ay/5aK1IdTzazpNxu5gw3qYIM72JAONg6Y51Lz7WrNj3E12Xj2coPmdxv3c2yz3+gYFp2CRaf2psOab+HDLdEyfBoaI0pwjDIcI4JjxHCMBI6RwjEyOEYFjhFczia4nM1wOZvhcjbD5WyGy9kMl7MZLmczXM7mF+fsjzZqBxvt9TbkgEyplG/fKymRLW3kDjaogw0+2MbDN36zDelgQzvYsCNs1LuN9mQ8SgcbtYONA+a5ss5fePLjy4xPNvQIG9bkZqPk5Zhb6mAjd7BxRC4pmmcbRZY2uIMN6WBDD7ZR89KGdbBROtg4IpfUPMduVdmplPROyO53/nT4Zw2KTklYdDIWHcKiw1h0BIuOYtExLDoFiw5WVi5YWbliZeWKlZUrVlauWFm5HpKV60ynEe/QyW3+pGv6874LksS/MVI4RgbHqMAxqnCMGhqjlnozopRmKWdKdckowzEiOEYMx0jgGCkcI+vPSGxm9HDvmVGBY1ThGDUwRpQSHKMMx4jgGDEcI4FjpHCM+s/+nG7tGKY/acEo94/sPL+zm6znJaP+kT29P5gZPbydnhkJHCOFY2RwjAocowrHqKExonQmoylpLxllOEYEx+iEnK33VcSW6xoJHCOFY2RwjAocowrHqKEx4gTHqH/OJpnrbCppyYjgGDEcI4FjpHCMDI5RgWNU4Rg1NEaS4BidkI/mLzDp8YvYmVH/ucb59iZ7+nO5O5L+c421zYxqWzKqcIwaGiNNcIwyHCOCY8RwjORMRpKWZ7WqcIwMjtEZOfu+iuhyXdMKx6ihMbIExyjDMSI4RgzHSOAYKRwjg2MEl7MNLmcbXM4ucDm7wOXs8uKc/dEGd7AhHWxoBxvWwUbpYOOI/NTmn2XRx98nmW0ckHEs2c2GpbrX48HSfGY1ARe6UzpCl3IwowzHiOAYMRwjgWOkr2X00YZ1sFE62KgdbLTX22ipg41D8tN27DbqYIM72JAONrSDDetgo3SwUTvYaC+3wSl1sJE72KAONriDDelgQzvYsA42SgcbtYONDvM8d5jnucM8zx3mee4wz3OHeZ47zPPcYZ7nDvM8d5jnucM8pw7znDrMc+owz6nDPKcO85w6zHPqMM+pwzynDvOcOsxz7jDPucM85w7znDvMc+4wz7nDPOcO85w7zHPuMM+5wzyXDvNcOsxz6TDPpcM8lw7zXDrMc+kwz6XDPJcO81w6zHPtMM+1wzzXDvNcO8xz7TDPtcM81w7zXDvMc+0wz7XDPLcO89w6zHPrMM+twzy3DvPcOsxz6zDPrcM8tw7z3DrM89JhnpcO87x0mOelwzwvHeZ56TDPS4c5+Ee+31v8ODn/kS/ylqg/8tXcE1R2ociFYhdKXCh1ocyFKi6UKzaqKzaaKzaaKzaaKzaaKzaaKzaaKzaaKzaaKzaaKzaaJzYkJRcqu1DkQrELJS6UulDmQhUXqrpQrtjIrtjIrtjIrtjIrtjIrtjIrtjIrtjIrtjIrtjIrtggV2yQKzbIFRvkig1yxQa5YoNcsUGu2CBXbJArNtgVG+yKDXbFBrtig12xwa7YYFdssCs22BUb7IoNccWGuGJDXLEhrtgQV2yIKzbEFRviig1xxYa4YkNdsaGu2FBXbKgrNtQVG+qKDXXFhrpiQ12xoa7YMFdsmCs2zBUb5ooNc8WGuWLDXLFhrtgwV2yYKzaKKzaKKzaKKzaKKzaKKzaKKzaKKzaKKzZc56LiOhcV17mouM5FxXUuKq5zUXGdi4rrXFT+wLno4+/PPz0rz5VvWvdcpc5Xa/7NRHm9ifp6E+3lJv7AWe5Xm8ivN0GvN8GvNyGvN6GvN/H62d1eP7vb62d3e/ns1pRebyK/3gS93gS/3sTLZ7dmtPa8esLP8jDNP4PBnJaMFI6RwTEqcIxOaK2W651RXjJqaIxO+FmePUYZjhHBMWI4RgLH6IScvdnkXQmt7bye8LM8e4wqHKOGxogTHKMMx4jgGDEcI4FjBJezGS5nM9pPzeoJPzmTefZR5uUOUjIcI4JjxHCM+uejTHJnVJaMFI6RwTEqcIwqHKOGxuiEny7aY3RCzt78wXJVtJ9Q1xN+umiPkcAxUjhGBseowDGqcIwaGqMTfrpojxFczja4nP3805qm6XZ62aZjuN/Z+Ih6mjOmrZbdmAk9iD3bE2JC828pCxV+vPijhfJyC/XlFtqrLTz/1OVQC/nlFujlFvjlFuTlFl4ere3V0WopvdxCfrkFerkFfrkFebkFfbmF165A0z/y26XPP/bIaT4EzYkfvnB5tl6XdFuuS6bHS6fHeP7lxnG3t6+/PfPt9tI+v3054PZ0u73x57evr719+/rb17lua+Wz2z//dOG42+evvn2l21yp8nnkPP+o4Atvf/v8pT78INyn2/PX377chrYunSMH3r59Nq2mf9DH1PA0fqTMCSjfI45F1mNiG5K/HEJfDuEvh8gXQqZ/8duVz6UNWuk2ONOfd49Pm4/J2HNhwzbmuaxhB5MdGHJg2IERB0YdGHNgigPjiIPqiIPmiIPmiIPmiIPmiIPmiIPmiIPmiIPmiIPmiIOVvcrvfsixfYbJK9uPHVD2gMgDYg9IdkFFFqAV79Xbmc+0j/rc4/l59xEjm0HUliD2gMQDUgfo+UppyrfKxaaz6AWIPSDxgNQDMg+oPAeZzaBaF6DqATUH6PknZXugvAtqvAA9d7nlGTTF0QJkHlDxgKoH1Byg59+o2BQ8M8gWiUXMA3r+JiPVeeuW2gL0/OWnWbvtmKyktACxByQe0PMwqjK7vOoiYJ+/iNsDFQ+oekDNAXr+UmgPlD0g8oBWxinPAVtpkSNWdPtp/oCgJFssNSuy/W3Qimp/e2qsiPZ3QOQBsQckHpB6QOYBFQ+oekCevFc9EVE9EVE9EVE9EVE9EVE9EVH3895yEtbmALXkAWUPaCXvzSJGa2mxuj/fp1mbj0utiS5A1QNqXw6i5zu1PdBz7zWqd5AtQOQBsQckHpB6QOYBFQcor4xTvcdeXYzTSvPLx5VQZAEiD4g9IPGA1AMyD6h4QNUDWlmfpKxXLLQi2Nwsc4iyB0QeEHtA4gGpB2QeUPGAHDUsPS8Ss9AswHj7uy1g7IM9f3kpd1n19Dcv0svzAm4fVn2w5oI9L+P2YdkHIx+MfTDxwXQFNh9TvMEWS1A1H6z4YNUHay5YS18Om/4hbxfbyvth5fs7UJXPJ52RC8UulLhQ6kKZC1VcqOpCNQ/q+QHBdFTTbov0dAJDnx9PPT8h2EWRC8Uu1PPYmK5sd5QsUOpCPfe8TYvSjJoOij5DrWRwy/X+XFPN/zkqu1DkQrELteJ5Ermj9PNUtZK891DmQhUXqrpQzYNaydt7qJXYIK13lH2eARq5UOxCrcXGw/yi8rv59aTf01RPz0amirfuXK73Dcf09+LVVVNATgbIqQByqoCcGh6nlS8XziaVEUkRIik+hRTXB1KLV1/pqGSe7qSKLaxoFyvWxUrpYqV2sdJ6WMmpi5XcxcpaZskPRR0tYeyDiQ+mPpj5YMUHqz5Yc8Eo+WDZB/NFCfmihNaipM1HbfbYpOcGUx/MfLDig1UXjFeGm9s9Gcjie9KVj8X2YSsukftZpwkvCgJeCWUt9+2XLl9fS/LBsg9GPhj7YOKDqQ9mPljxwVZC2WYBzvQ3Lyo0aWuwe3CZ5u11bUPk9kRavi6feyOkCY1QRiNEaIQYjZCgEVI0QoZGqIARsrWgLvcTeyvL7zZXHFvussAJtfxGdC17t3v2LikvYM0FK8kHyz4Y+WDsg4kPpj6Y+WAr0V7oMUoWJd3K9wO7sOaCrb192oOtREmx+zaj1MXX7Gvvn/Zg7IOJD6Y+mPlgxQdbiZKa7rCaF5lr7TXUDmztPdQeLPtga1HSHmGL4njtVdQeTHww9cHMBys+WPXB1qLkfhBsVT5PCrT2cmEPln0w8sFWoqTSI6wuYOKDqQ9mPljxwaoP1lywtaPc+lBz1ZoXsOyDkQ/GPthalNgjbPE55Nph6x7MfLDig1UfrLlga4ete7C1ukTu5Uz9vVjzyQk+lzpXdlza4gvDtbPZL7RS59Z409+0+Gx67Sj3YCvSxYp2sWJdrJQuVmoXK62HlbWj9C+1QuVuZfmRK+fjn+WJFepihbtYkS5WDpr7c2vT6e/FV5TE1sVK6WKldrHSeliR1MVK7mKFulg5aO7bw6wsi32QyPHP8sSKdrFiXayULlYOmvtt/gaFW1rkZGk9rGjqYiV3sUJdrHAXK9LFinaxcszcb+k+K1teHFpoOf5ZnlipXay0HlYsdbGSPW/iyMgHYx9MfDD1wcwHKz5Y9cGaC7b2TnMP5ouS4ouS4ouS4ouS4ouS4ouStbeM25+pramUTe4foptYWsCyD0Y+GPtg4oOpD2Y+WPHBqg/WXLDmi5Lmi5Lmi5Lmi5Lmi5LmihJeeQ+x0yiBV95D7MJcHQ84uzoeMCUfLPtg5IOxDyY+mPpg5oO5Oh4wVR/M1fGAOflg2QejL4dN/9C3i1d+MZXm9mN6n95Z9M3eyk+abkLkyyH65RD7Qsiv0z//99ufv//2bz989+8J8vZf//Pj33/5/qcfP/3zl//71+2//O3n73/44ft//vVfP//09+/+8Z+fv/vrDz/9/e2/fZM+/c+fbdrGGae/fOwQ/2c1/aBF//ImU3r7Z7EPWvPbP9+G2Vima+3+Cx1v10yvGJjmzvz86f8pt1tw/SA8N6D/CJiOc6a69JNFsw/FbhdPbyQ+TOfSN3vUygdqbW6s8fF+3D6w3dDTrbTN6FY/cOIbmpNM/7Q5bPjj//dB0u36aUXQidqvk1P/Hw==",
       "brillig_names": [
         "get_note_internal",
         "decompose_hint",
@@ -1625,8 +1793,8 @@
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "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",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-23a242543e813511e2bde8cad7572c07-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-dd38a381b25b33ff54a63a2b254cd73e-client-ivc-true"
     },
     {
       "name": "constructor",
@@ -1657,10 +1825,6 @@
             "error_kind": "string",
             "string": "Initializer address is not the contract deployer"
           },
-          "2429784973622283587": {
-            "error_kind": "string",
-            "string": "Can only emit a note log for an existing note."
-          },
           "2709101749560550278": {
             "error_kind": "string",
             "string": "Cannot serialize point at infinity as bytes."
@@ -1684,10 +1848,6 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -1699,10 +1859,6 @@
           "8193989641828211937": {
             "error_kind": "string",
             "string": "ciphertext length mismatch"
-          },
-          "8270195893599566439": {
-            "error_kind": "string",
-            "string": "Invalid public keys hint for address"
           }
         },
         "parameters": [
@@ -1810,7 +1966,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2048,7 +2204,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -2141,6 +2297,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -2928,7 +3105,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3166,7 +3343,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -3259,6 +3436,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -3277,15 +3475,14 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_contract_instance_internal",
         "decompose_hint",
         "lte_hint",
-        "get_public_keys_and_partial_address",
         "notify_created_note_oracle_wrapper",
-        "get_key_validation_request",
+        "debug_log_oracle_wrapper",
         "get_random_bytes",
         "random",
         "field_less_than",
@@ -3297,28 +3494,8 @@
         "directive_invert",
         "directive_to_radix"
       ],
-      "verification_key": "AAAAAAABAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAUAVrpNBMEhdad8F9dNtWuZeTe6U0AGwh+BIekTLJVSrty/669Y337+YJkoKc24x9F9BwwjXgjoT7xHwsJhK9NFvgAAAAAAAAAAAAoTnvNE3sm4EcdHzZxSu3kgj+tfA8SRuzRjUOJT/p5EKN0MtFIqIvxCaV0aUPhI6wRESCCbn6yaIqCBBgLY8L0eWkFLy6XTNyD9fN9HfLroljDnv+UFkQksXzDNw8473CuhqxUS4oh7iTsgj6T7YOopXdg5inZit/yALfuTaUD1Dn0yRzPMaezh003wmNEMqLzuQBdxHrlPsDKfJTUsm/0rPm4NkN5SWDkORSu9WkG1bLs8HgzgWzjOn9R/ZBF0kw8VrEXSNgEv5MD3x/D0hTee19anI4JrTXlGLRm08O+2Ah+PONU418vFWa/3KUMxaAW4coBS1yH36DRcFAwY/pEUKofPmJLTH5fjDbXnvIlnHoE2rns+28d2Pvz50JAqax5piLmP/W3AEhys7HxAT0NVJp9XsX0pat1jVs8geI+hCqKEpU9+/TTPEJKj1U+YgC3GjjpTng6J9V60Rkmd5A8DIuTAC4BVosi66Iyz20d90RQJwcqzynykyW/afs5UUREwbQYjHrVRG2pK9iKsGbyxqnoaJGcVIykX3t1/cAPjD2yfeNrQX1jnaMgHeENWtTzB8+anVLgiRdWDS0u993EZiGVnUwW73NsOYQgXldGhcbC6qZLK1YfPqqhsQOSc/QRfBivtUoVW/nPG8Sup7/L8yIvebw5GCpGjYEFyJzJ1Jl0rXeDsCIDqWZdssCJ79stpA6Dn7EuaMdRdpfHLPw4HMJs4IlCHqK7/UpiHhn1vMcg1Pq65AZLwGs9O466q3haN8mp0Pl7V2B+o0IyKT4ibrypzVbCPHlTmD7ewIozSEqDfxGcFhOYe0e+QmDu0jpGDKHUWGl/eysXDgaRmq/orNZ8Ci5uzFbj2bLIaiIsSfy3+lhm8JdHqVYwagx2qSAkRXtNCl8LJ5SWXkRXedTRnEun7tnJsvni8n3y/jzOQDPdo+/YSNkquKM3j81xvziVOd5E4xAtCGD/iI4hZwhIhBlk7qIM0M3YfNsexOGDsIRHz+MZgyZIiVCrt4Ej1jyB5S0RtQExLs9if/R4IzWqlcz+p0NYTDsgz/Kdz/SnzEiwdVSN9XzyCEOCaGbFkyXZ7X2L40jl5TGHTC3zC6PkULHnbYvWZ5flmxnCFzCvRFIAhgzUVaRaPiFiu9oVwEQPJyo0HMfy7Kxf8B2z/Ifba+oVj1Iwr2ggdZHetXhs5ABZk4RDrtBqfZO+Iuz/gZDydUFj4bwb9UJ+/RfrHTgIUmeyVmF7ywhOA5Y24acoyOdvxO5Ge2PGMaIbVROPmYQ7b1tA16lyoNfWpky6W8g53dUVigJ1UNNwcv6479zb+K9VVtyuUx7+QY/BTe2VzP+Jow7aRXgyIUJOz0WM3h18FI6FacS5pfyK3/b+BxDei6cFbgllr7ANrCiELAWuO9S2uChl/A6P4K1ujETcZnDiaSj+QAQ2LcjT+OWDHdUOBKsfO5WQoASXTlKbdpyb142Z3CVLqTR/cyHnvMe7JyfEIzk6I7eUXhP2BerygRLoHEQ2QWUTjBw7H/+8ugNIHdiqTUo80+cwqAWI98iwJvw2k3U7t14t91OGQDBqVEnldHeCxWywYisRMMOlK1p3t3wYx7OAB9yaNu0/f7x3QmIQkVq+QvxtdScJ4/hFrvjzuCTYsBVPNLCEMzVC4SQF7CSpv17/Uv9E1YiwlzW0HsrzWNxw1zE6e2ZTEjeXrjwisL4sDM/hyWaARNNH1OOg+sQIahQy6ZShckw5tLpFWlmYscQzf7OFX6Tj9NYbY74kZzpSw9rAlrNrADljVEb64kCmEvAvTP/wYbL+CEyY36L2leW/6+c8VLBZeETZdek/THV2TBRtVao6QtsqrhFdcStlDGnyE8gzPy6A486wy/PALJmV86mlK7KwkdEHGX8cnyZDZgbhr92L9EYCFywGQIwPW9YKLmFxOSJgC9oatp0jCnrf0hccT8E21TL/NNGdqF7/bBZawnBgotZjC8lVmiiQiF4sgweVC2kBwSLtGzEAKVvjOLOPNUIpKjtiafl/Caw8Tm1cOc0Uch+s+AzQAZQzq0nOjsl9A/hLxVC0nWuKEnUbrhtqlxupGsnwa6bN3INBxGewzynevV5KpDAuUhPGAj4v41rx54bxL4F1eqgwFpipMgBa+DyV/96BWlVHMUm63zPdOBDPDwXjjz6n9nyRUcDDCj53DA22prhPnejmlHpv+2BnEuxZEmwvsqo1ZAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhEQoeAkdvtG+OGwUAiXk7m4lmzBNE0/k6ptlQKUAeRbAnZjavWksyDYayf+AUmTeehpQfSFhvjtHtS+7fDVQHkPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvFFZ+LD6E/B4+adgfbOWAjKmgRRlkp7urvZ42nbdVYlMDeJJvFQwwx2CWXfRprm7WCcWf7s+JnyuVr/UZu/P7PA==",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-526bba47ae09428ece5fd936857db2a5-mega-honk-true"
-    },
-    {
-      "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/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLfCoMgFAbwdznXXcx/K3uVGGFlIYiG2WBE7z6LNtroRm8OfuLvePMt0MlmHmplejtBWS2gbSu8siakZc2gcUprNdTna7htA6H9/TQKs8XJC+ehxIRkIE0XThQF3ystoSScro8MEI4nJJ7QeMKiCb78hVN2Owynef5FCOEdsRR0T0F5CioSELnsAWeEfxBjxS9aQ3wKp0Sj5dGzfjbtqXb+Ncq/Bo7OtrKbndy6eKphmBXKM4zD2rD6DQ==",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-75564340eaf6aa0d51ac4e5113d29612-client-ivc-true"
     },
     {
       "name": "entrypoint",
@@ -3475,7 +3652,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -3713,7 +3890,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::header::Header"
+                    "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                   }
                 },
                 {
@@ -3806,6 +3983,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -4738,7 +4936,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -4976,7 +5174,7 @@
                     }
                   ],
                   "kind": "struct",
-                  "path": "authwit::aztec::protocol_types::header::Header"
+                  "path": "authwit::aztec::protocol_types::block_header::BlockHeader"
                 }
               },
               {
@@ -5069,9 +5267,30 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
-                          }
-                        ],
-                        "kind": "struct",
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
+                          }
+                        ],
+                        "kind": "struct",
                         "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
                       }
                     }
@@ -5087,8 +5306,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_note_internal",
         "decompose_hint",
@@ -5103,114 +5322,8 @@
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "AAAAAAABAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAUAVrpNBMEhdad8F9dNtWuZeTe6U0AGwh+BIekTLJVSrty/669Y337+YJkoKc24x9F9BwwjXgjoT7xHwsJhK9NFvgAAAAAAAAAAAAP3DM3vvlW9J0EfYY8NLKhoNCItF/gavuu6UuIPBoCQIBEuSaydW2VdzmyZ2Lc/lQDIbkTKaF2cXCvxw2ahxgQX3KFNdDqD1/XrYXunSaWRvWCQPTtvc0ZfJAgkEL6h/Slh1fZyafvHB3tb+L9qrVss8jToZ4aIjbyUkWjfWAiqIWq5vhOlHc8d/jfLHM2AqN7GpmHgihUL4qvBJQ7pW0geKbveqzu/kMy3pxNeefdITEzjx6PEssJetyy+YWG+6yS0aju7yc0QoAc33RzHI2xhq1zvXKHW7Xp1VcGk/n/rCl25ptgeu7kBVw3SyLGstUA449S87N2sNEXoimanorEnCd1pFu2stPQEJp9pDVUXymG/yqb6H3E+l/RsTCf5/QrDuoVjB3+HIpkGdcWQoayedtCJQXnVkVfM/XZrB5PGEfOH+iPTy1ZsDPwiPQRBDKIwtYkyoPSFL5/hQEAKjssLvGUfpraDpZBXt9pqk8+DehDZwBO4A4iohAoofat/3hEwbQYjHrVRG2pK9iKsGbyxqnoaJGcVIykX3t1/cAPjD2yfeNrQX1jnaMgHeENWtTzB8+anVLgiRdWDS0u993EETwdhK7TAGsELw5vbfEug3/NBR0wnuhOwn+sWOTpmUAHB9A7xQZIUUONPDI2bnD4OYDGG4T+xyTpxDokKshC3LJ1slgnfStocUJS/+ffOdsPw0NHuknsebRb4f+lKEKcHJNgcOJS6zSm3WnfaoasUxqZc+MD8lKse9UyV1y+3wRjzoEDGAowYSD30acFZHB060QPqjGRqWOMCByoDDoX1FWtgEB2iGTVD6XQvPa3Z5orm69S/MYkc66CSJhTZ0r8tibLCrkAuVapB/i7sFZufRIbOq5k18SaKefnQrueh7SwmluVHXSGCpCXpmwqEztNPkr7tCqotv22eN6ANbVZ5Ajirk4MZdyhVvVqTW1P4JraX1KmXKelrilQmfD0NjnwhvaZgWd8oVOV+GB5vKv7UNYSVuDZy+yLRF+ysVcdgUSSnqJ57i7fpaGNFwDF2ACh/zvoaQrGc/ggJt+ONnJENBdjXx5+QpVRRjASyqg2U8+ylhze3mwUR13YOE2pvocQgZr4aPA56RQifP6lVdyv9zmtYWkabsxA0EiXmkpV+4yhzhoKbTSHrJmk2vIJqk6YlhdeLQL0DqjjLEIKMYTWwFxGKQsw1BadqS8mq4+BpXHGmtqzsCQb9dvQQ66ZYLjcY4bHkjPoo+/XX0MNceq/UGaM4WXi/2cWGHabWBjNx9Bdmr8hMC2sscU1N4CgbP6foWEoQE+wDS3QE/fBIe8iFINiGM+GVRic4YJ1RKZOy8qBuc59gQ6uYwLPpt7wmX/8pl1djEaeL+bBVgL9SG4c23GhHgrW3Wp/L6OYCsSf4qQi/4g+HAZ8RL9MjlIQ1Nl85vvmQkHmtPbaNOfxe2zMCK0T1MH/hy8KbdQI8QHPM9K9vAkc9owZe2dFiGsmCDRET+0JDixseCanaN+vMt2DgsGTFczJw3AY4S21p/NuuBBeZKnX/xaUHLrif2vnmUH2leTbh6regCfSi/rzx2zgcAN7RScyTDWCjG8IL8584FxAHbrHizWhgZYIp1Hzs0JcdOfkP4A/aZictVnfZRpaMMHM9Dw5BCfQ35r5rn2s0px5Ud1HKkeJn8P7KFjTFpq3PUFBXTJ1RKVhfBF4ga/sMElD4uV7wvMYuMgqnMrn/OsHqUjb6Cd+H/lWt0Py4LPEvYyx1o7o+9h+Zyi9qlqUNSfkc054xqI2toVUBU1OCUhdpgo7VbpXUyiXOR4Q6uTtCaDgdON8vtvIXmOTI+jT9G+Wq7VwodFfVIWkuCvbKO8qpDmJ1f0RdGlnBz5OmOfQngKpHE7ry9MGiMraLuON4GNh2KnkeHus4DmSt//ROUQP3ozD64BHslQ1vEjt1AvaTGJBbf5pkee8OnqMT9uNZEg4AcFL2rHv1UaIgF5MbdNe70TBtYRrZN4G6hVK4B78QTqOoggVsenvZaCO3SwI/5PuG73r81OAupq8v+jV+hB3F1AzJq9gfNe94i+jXELtI5ifvk+kwdIGPPmEJUU77BCkU9jrC+OD58ciB5BzNoFgmMG497bytmPqQXsCruc0qEYNZJvjsplBUqErPcQucDn7yMP0dESdDCRyiqmekbRADlP8X/sJVMlPLtXt/L8R98eFsodJhMRdQR/xne/cIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAid81V7V9SLp5oP+8rM06CdCV/20cgF85kjpCYlE2ljlLW8Kxqm4OmRq1tH5/0wWVEBR5y/z2RmTzqLOFSGTckoPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvFFZ+LD6E/B4+adgfbOWAjKmgRRlkp7urvZ42nbdVYlMDeJJvFQwwx2CWXfRprm7WCcWf7s+JnyuVr/UZu/P7PA==",
-      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-bd12abe6cba7e5628df345b993bda324-mega-honk-true"
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "11091894166229312484": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 20
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "8270195893599566439": {
-            "error_kind": "string",
-            "string": "Invalid public keys hint for address"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 5,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-2d441d05102d6ffcfc00217739092179-client-ivc-true"
     }
   ],
   "outputs": {
@@ -5385,6 +5498,33 @@
           "kind": "struct",
           "path": "EcdsaKAccount::constructor_abi"
         },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "EcdsaKAccount::verify_private_authwit_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "EcdsaKAccount::verify_private_authwit_abi"
+        },
         {
           "fields": [
             {
@@ -5567,42 +5707,11 @@
           ],
           "kind": "struct",
           "path": "EcdsaKAccount::entrypoint_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner_hash",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "EcdsaKAccount::verify_private_authwit_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "EcdsaKAccount::verify_private_authwit_abi"
         }
       ]
     }
   },
   "file_map": {
-    "3": {
-      "path": "std/array/mod.nr",
-      "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a slice.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let slice = array.as_slice();\n    /// assert_eq(slice, &[1, 2]);\n    /// ```\n    #[builtin(as_slice)]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the `sort_via` function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(self) -> Self {\n        self.sort_via(|a: T, b: T| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n        unsafe {\n            // Safety: `sorted` array is checked to be:\n            //   a. a permutation of `input`'s elements\n            //   b. satisfying the predicate `ordering`\n            let sorted = quicksort::quicksort(self, ordering);\n\n            if !is_unconstrained() {\n                for i in 0..N - 1 {\n                    assert(\n                        ordering(sorted[i], sorted[i + 1]),\n                        \"Array has not been sorted correctly according to `ordering`.\",\n                    );\n                }\n                check_shuffle::check_shuffle(self, sorted);\n            }\n            sorted\n        }\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n}\n"
-    },
     "6": {
       "path": "std/cmp.nr",
       "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: StructDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for u1 {\n    fn eq(self, other: u1) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\nimpl<A, B> Eq for (A, B)\nwhere\n    A: Eq,\n    B: Eq,\n{\n    fn eq(self, other: (A, B)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1)\n    }\n}\n\nimpl<A, B, C> Eq for (A, B, C)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n{\n    fn eq(self, other: (A, B, C)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n    }\n}\n\nimpl<A, B, C, D> Eq for (A, B, C, D)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n{\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n    }\n}\n\nimpl<A, B, C, D, E> Eq for (A, B, C, D, E)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n    E: Eq,\n{\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        self.0.eq(other.0)\n            & self.1.eq(other.1)\n            & self.2.eq(other.2)\n            & self.3.eq(other.3)\n            & self.4.eq(other.4)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: StructDefinition) -> Quoted {\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == std::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = std::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let mut result = self.len().cmp(other.len());\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<A, B> Ord for (A, B)\nwhere\n    A: Ord,\n    B: Ord,\n{\n    fn cmp(self, other: (A, B)) -> Ordering {\n        let result = self.0.cmp(other.0);\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self.1.cmp(other.1)\n        }\n    }\n}\n\nimpl<A, B, C> Ord for (A, B, C)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n{\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D> Ord for (A, B, C, D)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n{\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D, E> Ord for (A, B, C, D, E)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n    E: Ord,\n{\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        if result == Ordering::equal() {\n            result = self.4.cmp(other.4);\n        }\n\n        result\n    }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use crate::cmp::{max, min};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0 as u64, 1 as u64), 0);\n        assert_eq(min(0 as u64, 0 as u64), 0);\n        assert_eq(min(1 as u64, 1 as u64), 1);\n        assert_eq(min(255 as u8, 0 as u8), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0 as u64, 1 as u64), 1);\n        assert_eq(max(0 as u64, 0 as u64), 0);\n        assert_eq(max(1 as u64, 1 as u64), 1);\n        assert_eq(max(255 as u8, 0 as u8), 255);\n    }\n}\n"
@@ -5635,183 +5744,187 @@
       "path": "std/hash/sha256.nr",
       "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
     },
-    "50": {
+    "51": {
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
     },
-    "51": {
+    "52": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "75": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr",
-      "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::note::{\n    note_emission::NoteEmission,\n    note_header::NoteHeader,\n    note_interface::{NoteInterface, NullifiableNote},\n    utils::{compute_note_hash_for_nullify_internal, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n) -> NoteEmission<Note>\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    let note_hash_counter = context.side_effect_counter;\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    let serialized_note = Note::serialize_content(*note);\n    notify_created_note(\n        storage_slot,\n        Note::get_note_type_id(),\n        serialized_note,\n        note_hash,\n        note_hash_counter,\n    );\n\n    context.push_note_hash(note_hash);\n\n    NoteEmission::new(*note)\n}\n\npub fn create_note_hash_from_public<Note, let N: u32>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    // Public note hashes are transient, but have no side effect counters, so we just need note_hash_counter != 0\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter: 1 };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    context.push_note_hash(note_hash);\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note<Note, let N: u32>(context: &mut PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n\n    destroy_note_unsafe(context, note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe<Note, let N: u32>(\n    context: &mut PrivateContext,\n    note: Note,\n    note_hash_for_read_request: Field,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_nullify =\n        compute_note_hash_for_nullify_internal(note, note_hash_for_read_request);\n    let nullifier = note.compute_nullifier(context, note_hash_for_nullify);\n\n    let note_hash_counter = note.get_header().note_hash_counter;\n    let notification_note_hash = if (note_hash_counter == 0) {\n        // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n        0\n    } else {\n        // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n        // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n        // hash with real value to inform the kernel which note we're nullifyng so that it can either squash both\n        // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n        // a siloed note hash.\n        note_hash_for_nullify\n    };\n\n    let nullifier_counter = context.side_effect_counter;\n    notify_nullified_note(nullifier, notification_note_hash, nullifier_counter);\n\n    context.push_nullifier_for_note_hash(nullifier, notification_note_hash)\n}\n"
-    },
-    "78": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/utils.nr",
-      "source": "use crate::{\n    context::PrivateContext,\n    note::{note_header::NoteHeader, note_interface::{NoteInterface, NullifiableNote}},\n};\n\nuse dep::protocol_types::{\n    hash::{\n        compute_siloed_note_hash as compute_siloed_note_hash,\n        compute_siloed_nullifier as compute_siloed_nullifier_from_preimage,\n        compute_unique_note_hash,\n    },\n    utils::arr_copy_slice,\n};\n\npub fn compute_siloed_nullifier<Note, let N: u32>(\n    note_with_header: Note,\n    context: &mut PrivateContext,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note_with_header.get_header();\n    let note_hash_for_nullify = compute_note_hash_for_nullify(note_with_header);\n    let inner_nullifier = note_with_header.compute_nullifier(context, note_hash_for_nullify);\n\n    compute_siloed_nullifier_from_preimage(header.contract_address, inner_nullifier)\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_read_request<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash = note.compute_note_hash();\n    let nonce = note.get_header().nonce;\n    let counter = note.get_header().note_hash_counter;\n\n    if counter != 0 {\n        note_hash\n    } else {\n        compute_unique_note_hash(nonce, note_hash)\n    }\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_nullify_internal<Note, let N: u32>(\n    note: Note,\n    note_hash_for_read_request: Field,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note.get_header();\n\n    if header.note_hash_counter != 0 {\n        if header.nonce == 0 {\n            // Case 1: Transient note\n            note_hash_for_read_request\n        } else {\n            // Case 2: Non-revertible note, nullified by a revertible nullifier\n            let unique_note_hash =\n                compute_unique_note_hash(header.nonce, note_hash_for_read_request);\n            compute_siloed_note_hash(header.contract_address, unique_note_hash)\n        }\n    } else {\n        // Case 3: Note from a previous transaction\n        // note_hash_for_read_request is already the unique_note_hash in this case\n        compute_siloed_note_hash(header.contract_address, note_hash_for_read_request)\n    }\n}\n\n// TODO(#7775): nuke this commented out code - kept it around as it contains comments which might be helpful when tackling #7775\n// pub fn compute_note_hash_for_nullify<Note, let N: u32, let M: u32>(note: Note) -> Field where Note: NoteInterface<N> {\n//     let header = note.get_header();\n//     // There are 3 cases for reading a note intended for consumption:\n//     // 1. The note was inserted in this transaction, is revertible, or is not nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce == 0)\n//     // 2. The note was inserted in this transaction, is non-revertible, and is nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce != 0)\n//     // 3. The note was inserted in a previous transaction: (note_hash_counter == 0) & (nonce != 0)\n\n//     let note_hash = note.compute_note_hiding_point().x;\n\n//     if header.nonce == 0 {\n//         // Case 1.\n//         // If a note is transient, we just read the note_hash (kernel will hash it with nonce and silo by contract address).\n//         note_hash\n//     } else {\n//         // Case 2: If a note is non-revertible, and is nullified by a revertible nullifier, we cannot squash them in the\n//         // private reset circuit. Because if the tx reverts, we will have to keep the note hash and throw away the\n//         // nullifier.\n//         // And if the tx does not revert, both will be emitted. In which case, the nullifier must be created in the app\n//         // from the siloed note hash.\n//         // The kernel circuit will check that a nullifier with non-zero note_nonce is linked to a note hash, whose\n//         // siloed note hash matches the note hash specified in the nullifier.\n\n//         // Case 3: If a note is not from the current transaction, that means we are reading a settled note (from\n//         // tree) created in a previous TX. So we need the siloed_note_hash which has already been hashed with\n//         // nonce and then contract address. This hash will match the existing leaf in the note hash\n//         // tree, so the kernel can just perform a membership check directly on this hash/leaf.\n//         let unique_note_hash = compute_unique_note_hash(header.nonce, note_hash);\n//         compute_siloed_note_hash(header.contract_address, unique_note_hash)\n//         // IMPORTANT NOTE ON REDUNDANT SILOING BY CONTRACT ADDRESS: The note hash computed above is\n//         // \"siloed\" by contract address. When a note hash is computed solely for the purpose of\n//         // nullification, it is not strictly necessary to silo the note hash before computing\n//         // its nullifier. In other words, it is NOT NECESSARY for protocol security that a nullifier\n//         // be computed from a siloed note hash. After all, persistable note hashes and nullifiers are\n//         // siloed by the kernel circuit. That being said, the siloed note hash computed above CAN be\n//         // used for nullifier computation, and this achieves the (arguably unnecessary) property that\n//         // nullifiers are computed from a note hash's fully-computed note hash tree leaf.\n//     }\n// }\n\npub fn compute_note_hash_for_nullify<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    compute_note_hash_for_nullify_internal(note, note_hash_for_read_request)\n}\n\npub unconstrained fn compute_note_hash_and_optionally_a_nullifier<T, let N: u32, let S: u32>(\n    deserialize_content: fn([Field; N]) -> T,\n    note_header: NoteHeader,\n    compute_nullifier: bool,\n    serialized_note: [Field; S],\n) -> [Field; 4]\nwhere\n    T: NoteInterface<N> + NullifiableNote,\n{\n    let mut note = deserialize_content(arr_copy_slice(serialized_note, [0; N], 0));\n    note.set_header(note_header);\n\n    let note_hash = note.compute_note_hash();\n    let unique_note_hash = compute_unique_note_hash(note_header.nonce, note_hash);\n    let siloed_note_hash = compute_siloed_note_hash(note_header.contract_address, unique_note_hash);\n\n    let inner_nullifier = if compute_nullifier {\n        note.compute_nullifier_without_context()\n    } else {\n        0\n    };\n    // docs:start:compute_note_hash_and_optionally_a_nullifier_returns\n    [note_hash, unique_note_hash, siloed_note_hash, inner_nullifier]\n    // docs:end:compute_note_hash_and_optionally_a_nullifier_returns\n}\n"
+    "66": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n/// ```\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "82": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_emission.nr",
-      "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission<Note> {\n    pub note: Note,\n}\n\nimpl<Note> NoteEmission<Note> {\n    pub fn new(note: Note) -> Self {\n        Self { note }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](Self) -> ()) {\n        _emit(self);\n    }\n\n    pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option<T>`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission<Note> {\n    emission: Option<NoteEmission<Note>>,\n}\n\nimpl<Note> OuterNoteEmission<Note> {\n    pub fn new(emission: Option<NoteEmission<Note>>) -> Self {\n        Self { emission }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](NoteEmission<Note>) -> ()) {\n        if self.emission.is_some() {\n            _emit(self.emission.unwrap());\n        }\n    }\n\n    pub fn discard(_self: Self) {}\n}\n"
+    "71": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/point.nr",
+      "source": "use dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a public key to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(pk: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!pk.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = pk.x.to_be_bytes();\n\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    if !BN254_FR_MODULUS_DIV_2.lt(pk.y) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\nmod test {\n    use crate::utils::point::point_to_bytes;\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n}\n"
     },
-    "85": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_getter/mod.nr",
-      "source": "use crate::context::PrivateContext;\nuse crate::note::{\n    constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n    note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::comparison::compare;\nuse dep::protocol_types::constants::{\n    GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector<let N: u32>(\n    serialized_note: [Field; N],\n    selector: PropertySelector,\n) -> Field {\n    // Selectors use PropertySelectors in order to locate note properties inside the serialized note.\n    // This allows easier packing and custom (de)serialization schemas. A note property is located\n    // inside the serialized note using the index inside the array, a byte offset and a length.\n    let value: [u8; 32] = serialized_note[selector.index].to_be_bytes();\n    let offset = selector.offset;\n    let length = selector.length;\n    let mut value_field = 0 as Field;\n    let mut acc: Field = 1;\n    for i in 0..32 {\n        if i < length {\n            value_field += value[31 + offset - i] as Field * acc;\n            acc = acc * 256;\n        }\n    }\n    value_field\n}\n\nfn check_note_header<Note, let N: u32>(context: PrivateContext, storage_slot: Field, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let header = note.get_header();\n    let contract_address = context.this_address();\n    assert(header.contract_address.eq(contract_address), \"Mismatch note header contract address.\");\n    assert(header.storage_slot == storage_slot, \"Mismatch note header storage slot.\");\n}\n\nfn check_note_fields<let N: u32>(\n    serialized_note: [Field; N],\n    selects: BoundedVec<Option<Select>, N>,\n) {\n    for i in 0..selects.len() {\n        let select = selects.get_unchecked(i).unwrap_unchecked();\n        let value_field =\n            extract_property_value_from_selector(serialized_note, select.property_selector);\n\n        assert(\n            compare(value_field, select.comparator, select.value.to_field()),\n            \"Mismatch return note field.\",\n        );\n    }\n}\n\nfn check_notes_order<let N: u32>(\n    fields_0: [Field; N],\n    fields_1: [Field; N],\n    sorts: BoundedVec<Option<Sort>, N>,\n) {\n    for i in 0..sorts.len() {\n        let sort = sorts.get_unchecked(i).unwrap_unchecked();\n        let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n        let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n        let eq = field_0 == field_1;\n        let lt = field_0.lt(field_1);\n        if sort.order == SortOrder.ASC {\n            assert(eq | lt, \"Return notes not sorted in ascending order.\");\n        } else if !eq {\n            assert(!lt, \"Return notes not sorted in descending order.\");\n        }\n    }\n}\n\npub fn get_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n) -> (Note, Field)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note = unsafe { get_note_internal(storage_slot) };\n\n    // Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do is check that\n    // the metadata is correct, and that the note exists.\n    check_note_header(*context, storage_slot, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    context.push_note_hash_read_request(note_hash_for_read_request);\n\n    (note, note_hash_for_read_request)\n}\n\npub fn get_notes<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n    // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n    // these checks correctly reject bad notes.\n    constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor<Note, PREPROCESSOR_ARGS>(\n    notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor: fn([Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n    preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    opt_notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n    // while the filter function can technically mutate the contents of the notes (as opposed to simply removing some),\n    // the private kernel will later validate that these note actually exist, so transformations would cause for that\n    // check to fail.\n    let filter_fn = options.filter;\n    let filter_args = options.filter_args;\n    let filtered_notes = filter_fn(opt_notes, filter_args);\n\n    let notes = crate::utils::collapse_array(filtered_notes);\n    let mut note_hashes: BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> =\n        BoundedVec::new();\n\n    // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n    // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n    // for the runtime length, and can therefore have fewer loop iterations.\n    assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n    let mut prev_fields = [0; N];\n    for i in 0..options.limit {\n        if i < notes.len() {\n            let note = notes.get_unchecked(i);\n            let fields = note.serialize_content();\n            check_note_header(*context, storage_slot, note);\n            check_note_fields(fields, options.selects);\n            if i != 0 {\n                check_notes_order(prev_fields, fields, options.sorts);\n            }\n            prev_fields = fields;\n\n            let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n            // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n            context.push_note_hash_read_request(note_hash_for_read_request);\n            note_hashes.push(note_hash_for_read_request);\n        };\n    }\n\n    (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal<Note, let N: u32>(storage_slot: Field) -> Note\nwhere\n    Note: NoteInterface<N>,\n{\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n    oracle::notes::get_notes(\n        storage_slot,\n        0,\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        NoteStatus.ACTIVE,\n        placeholder_note,\n        placeholder_fields,\n        placeholder_note_length,\n    )[0]\n        .expect(f\"Failed to get a note\") // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n    Note: NoteInterface<N>,\n{\n    // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let opt_notes = oracle::notes::get_notes(\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        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\npub unconstrained fn view_notes<Note, let N: u32>(\n    storage_slot: Field,\n    options: NoteViewerOptions<Note, N>,\n) -> BoundedVec<Note, MAX_NOTES_PER_PAGE>\nwhere\n    Note: NoteInterface<N>,\n{\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let notes_array = oracle::notes::get_notes(\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        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    let mut notes = BoundedVec::new();\n    for i in 0..notes_array.len() {\n        if notes_array[i].is_some() {\n            notes.push(notes_array[i].unwrap_unchecked());\n        }\n    }\n\n    notes\n}\n\nunconstrained fn flatten_options<let N: u32>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n    let mut num_selects = 0;\n    let mut select_by_indexes = [0; N];\n    let mut select_by_offsets = [0; N];\n    let mut select_by_lengths = [0; N];\n    let mut select_values = [0; N];\n    let mut select_comparators = [0; N];\n\n    for i in 0..selects.len() {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n            select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n            select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n            num_selects += 1;\n        };\n    }\n\n    let mut sort_by_indexes = [0; N];\n    let mut sort_by_offsets = [0; N];\n    let mut sort_by_lengths = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len() {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n            sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n            sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    }\n\n    (\n        num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n        select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n    )\n}\n"
+    "77": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/private_immutable.nr",
+      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize},\n};\n\nuse crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n    lifecycle::create_note,\n    note_emission::NoteEmission,\n    note_getter::{get_note, view_notes},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n};\nuse crate::oracle::notes::check_nullifier_exists;\nuse crate::state_vars::storage::Storage;\n\n// docs:start:struct\npub struct PrivateImmutable<Note, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PrivateImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<Note, Context> PrivateImmutable<Note, Context> {\n    // docs:start:new\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n    // docs:end:new\n\n    // The following computation is leaky, in that it doesn't hide the storage slot that has been initialized, nor does it hide the contract address of this contract.\n    // When this initialization nullifier is emitted, an observer could do a dictionary or rainbow attack to learn the preimage of this nullifier to deduce the storage slot and contract address.\n    // For some applications, leaking the details that a particular state variable of a particular contract has been initialized will be unacceptable.\n    // Under such circumstances, such application developers might wish to _not_ use this state variable type.\n    // This is especially dangerous for initial assignment to elements of a `Map<AztecAddress, PrivateImmutable>` type (for example), because the storage slot often also identifies an actor.\n    // e.g. the initial assignment to `my_map.at(msg.sender)` will leak: `msg.sender`, the fact that an element of `my_map` was assigned-to for the first time, and the contract_address.\n    pub fn compute_initialization_nullifier(self) -> Field {\n        poseidon2_hash_with_separator(\n            [self.storage_slot],\n            GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n        )\n    }\n}\n\nimpl<Note> PrivateImmutable<Note, &mut PrivateContext> {\n    // docs:start:initialize\n    pub fn initialize<let N: u32>(self, note: &mut Note) -> NoteEmission<Note>\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        // Nullify the storage slot.\n        let nullifier = self.compute_initialization_nullifier();\n        self.context.push_nullifier(nullifier);\n\n        create_note(self.context, self.storage_slot, note)\n    }\n    // docs:end:initialize\n\n    // docs:start:get_note\n    pub fn get_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let storage_slot = self.storage_slot;\n        get_note(self.context, storage_slot).0\n    }\n    // docs:end:get_note\n}\n\nimpl<Note> PrivateImmutable<Note, UnconstrainedContext> {\n    // docs:start:is_initialized\n    pub unconstrained fn is_initialized(self) -> bool {\n        let nullifier = self.compute_initialization_nullifier();\n        check_nullifier_exists(nullifier)\n    }\n    // docs:end:is_initialized\n\n    // view_note does not actually use the context, but it calls oracles that are only available in private\n    // docs:start:view_note\n    pub unconstrained fn view_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let mut options = NoteViewerOptions::new();\n        view_notes(self.storage_slot, options.set_limit(1)).get(0)\n    }\n    // docs:end:view_note\n}\n"
     },
-    "93": {
+    "98": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\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        arguments,\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        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\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    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    header::Header,\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: Header,\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 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\n    pub fn push_nullifier(&mut self, nullifier: Field) {\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        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_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_header(self) -> Header {\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_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(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            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\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    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\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    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\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    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(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    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\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        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // 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        PackedReturns::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        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\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        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\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_packed_args(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_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\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        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks 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 = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\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        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\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        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks 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 = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\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: Header::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, packed_returns::PackedReturns},\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        arguments,\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        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\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 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        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        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_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        pack_returns(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            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\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    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\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    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\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    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(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    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\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        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // 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        PackedReturns::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        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\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        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\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_packed_args(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_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\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        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks 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 = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\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        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\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        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks 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 = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\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": "/usr/src/noir-projects/aztec-nr/aztec/src/initializer.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress,\n    constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext},\n    oracle::get_contract_instance::{\n        get_contract_instance, get_contract_instance_deployer_avm,\n        get_contract_instance_initialization_hash_avm,\n    },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n    address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n    let address = context.this_address();\n    let deployer = get_contract_instance_deployer_avm(address).unwrap();\n    let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (deployer.is_zero()) | (deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n    let address = context.this_address();\n    let instance = get_contract_instance(address);\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn compute_initialization_hash(\n    init_selector: FunctionSelector,\n    init_args_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [init_selector.to_field(), init_args_hash],\n        GENERATOR_INDEX__CONSTRUCTOR,\n    )\n}\n"
+    "100": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    point::Point,\n    public_keys::{IvpkM, ToPoint},\n    scalar::Scalar,\n};\n\nuse crate::keys::secret_derivation::derive_aes_secret;\n\nuse std::aes128::aes128_encrypt;\n\npub struct EncryptedLogHeader {\n    address: AztecAddress,\n}\n\nimpl EncryptedLogHeader {\n    pub fn new(address: AztecAddress) -> Self {\n        EncryptedLogHeader { address }\n    }\n\n    pub fn compute_ciphertext<T>(self, secret: Scalar, pk: T) -> [u8; 48]\n    where\n        T: ToPoint,\n    {\n        let full_key = derive_aes_secret(secret, pk.to_point());\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n\n        for i in 0..16 {\n            sym_key[i] = full_key[i];\n            iv[i] = full_key[i + 16];\n        }\n\n        let input: [u8; 32] = self.address.to_field().to_be_bytes();\n        aes128_encrypt(input, iv, sym_key).as_array()\n    }\n}\n\n#[test]\nunconstrained fn test_encrypted_log_header_matches_noir() {\n    let address = AztecAddress::from_field(0xdeadbeef);\n    let header = EncryptedLogHeader::new(address);\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = IvpkM {\n        inner: Point {\n            x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n            y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n            is_infinite: false,\n        },\n    };\n\n    let ciphertext = header.compute_ciphertext(secret, point);\n\n    // The following value was generated by `encrypted_log_header.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_header_ciphertext_from_typescript = [\n        226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 194, 44, 7, 131,\n        160, 83, 64, 181, 98, 38, 153, 214, 62, 171, 253, 161, 111, 191, 28, 247, 216, 26, 222, 171,\n        176, 218, 48, 209, 73, 89, 200, 209,\n    ];\n\n    assert_eq(ciphertext, expected_header_ciphertext_from_typescript);\n}\n"
     },
-    "110": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::CONTRACT_INSTANCE_LENGTH, contract_class_id::ContractClassId,\n    contract_instance::ContractInstance,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(\n    _address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(\n    address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n    get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n    let instance =\n        unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\n    // The to_address function combines all values in the instance object to produce an address, so by checking that we\n    // get the expected address we validate the entire struct.\n    assert_eq(instance.to_address(), address);\n\n    instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {\n    let (member, exists) = get_contract_instance_deployer_internal_avm(address);\n    if exists {\n        Option::some(AztecAddress::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {\n    let (member, exists) = get_contract_instance_class_id_internal_avm(address);\n    if exists {\n        Option::some(ContractClassId::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {\n    let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
+    "103": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{GENERATOR_INDEX__SYMMETRIC_KEY, PRIVATE_LOG_SIZE_IN_FIELDS},\n    hash::poseidon2_hash,\n    point::Point,\n    public_keys::AddressPoint,\n    scalar::Scalar,\n    utils::arrays::array_concat,\n};\nuse std::{\n    aes128::aes128_encrypt, embedded_curve_ops::fixed_base_scalar_mul as derive_public_key,\n    field::bn254::decompose, hash::from_field_unsafe as fr_to_fq_unsafe,\n};\n\nuse crate::{\n    encrypted_logs::header::EncryptedLogHeader,\n    keys::secret_derivation::derive_aes_secret,\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::bytes_to_fields, point::point_to_bytes},\n};\n\n// 1 field is reserved for tag.\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n\ncomptime global HEADER_SIZE: u32 = 48;\n\n// Bytes padded to the overhead, so that the size of the incoming body ciphertext will be a multiple of 16.\ncomptime global OVERHEAD_PADDING: u32 = 15;\n\npub comptime global OVERHEAD_SIZE: u32 = 32 /* eph_pk */\n    + HEADER_SIZE /* incoming_header */\n    + OVERHEAD_PADDING /* padding */;\n\nglobal PLAINTEXT_LENGTH_SIZE: u32 = 2;\n\n// This is enough for 8 fields of data.\n// 1 field for storage slot, 1 field for note/event type id, allowing 6 fields for custom values.\nglobal MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n    ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\n// Note: Might have to update PRIVATE_LOG_SIZE_IN_FIELDS in `constants.nr` if the above changes.\n// This value ideally should be set by the protocol, allowing users (or `aztec-nr`) to fit data within the defined size limits.\n// Currently, we adjust this value as the structure changes, then update `constants.nr` to match.\n// Once the structure is finalized with defined overhead and max note field sizes, this value will be fixed and should remain unaffected by further payload composition changes.\n\npub fn compute_private_log_payload<let P: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n    assert(\n        P < MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n        f\"plaintext for log must not exceed {MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES}\",\n    );\n\n    let extended_plaintext: [u8; MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n    array_concat([tag], bytes_to_fields(encrypted))\n}\n\npub fn compute_partial_public_log_payload<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let extended_plaintext: [u8; P + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; M - 32] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n    // Silo the tag with contract address.\n    // This is done by the kernel circuit to the private logs, but since the partial log will be finalized and emitted\n    // in public as unencrypted log, its tag is not siloed at the moment.\n    // To avoid querying logs using two types of tags, we silo the tag manually here.\n    // TODO(#10273) This should be done by the AVM when it's processing the raw logs instead of their hashes.\n    let siloed_tag_bytes: [u8; 32] =\n        poseidon2_hash([contract_address.to_field(), tag]).to_be_bytes();\n\n    // Temporary hack so that the partial public log remains the same format.\n    // It should return field array and make the tag the first field as compute_private_log_payload does.\n    let mut log_bytes = [0; M];\n    for i in 0..32 {\n        log_bytes[i] = siloed_tag_bytes[i];\n    }\n    for i in 0..encrypted.len() {\n        log_bytes[i + 32] = encrypted[i];\n    }\n\n    log_bytes\n}\n\nfn compute_encrypted_log<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let header = EncryptedLogHeader::new(contract_address);\n\n    let incoming_header_ciphertext: [u8; 48] =\n        header.compute_ciphertext(eph_sk, recipient.to_address_point());\n    let incoming_body_ciphertext =\n        compute_incoming_body_ciphertext(plaintext, eph_sk, recipient.to_address_point());\n\n    let mut encrypted_bytes = [0; M];\n    let mut offset = 0;\n\n    // eph_pk\n    let eph_pk_bytes = point_to_bytes(eph_pk);\n    for i in 0..32 {\n        encrypted_bytes[offset + i] = eph_pk_bytes[i];\n    }\n    offset += 32;\n\n    // incoming_header\n    for i in 0..HEADER_SIZE {\n        encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n    }\n    offset += HEADER_SIZE;\n\n    // Padding.\n    offset += OVERHEAD_PADDING;\n\n    // incoming_body\n    // Then we fill in the rest as the incoming body ciphertext\n    let size = M - offset;\n    assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n    for i in 0..size {\n        encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n    }\n\n    encrypted_bytes\n}\n\n// Prepend the plaintext length as the first byte, then copy the plaintext itself starting from the second byte.\n// Fill the remaining bytes with random values to reach a fixed length of N.\nfn extend_private_log_plaintext<let P: u32, let N: u32>(plaintext: [u8; P]) -> [u8; N] {\n    let mut padded = unsafe { get_random_bytes() };\n    padded[0] = (P >> 8) as u8;\n    padded[1] = P as u8;\n    for i in 0..P {\n        padded[i + PLAINTEXT_LENGTH_SIZE] = plaintext[i];\n    }\n    padded\n}\n\nunconstrained fn get_random_bytes<let N: u32>() -> [u8; N] {\n    let mut bytes = [0; N];\n    let mut idx = 32;\n    let mut randomness = [0; 32];\n    for i in 0..N {\n        if idx == 32 {\n            randomness = random().to_be_bytes();\n            idx = 1; // Skip the first byte as it's always 0.\n        }\n        bytes[i] = randomness[idx];\n        idx += 1;\n    }\n    bytes\n}\n\n/// Converts a base field element to scalar field element.\n/// This is fine because modulus of the base field is smaller than the modulus of the scalar field.\nfn fr_to_fq(r: Field) -> Scalar {\n    let (lo, hi) = decompose(r);\n\n    Scalar { lo, hi }\n}\n\nfn generate_ephemeral_key_pair() -> (Scalar, Point) {\n    // @todo Need to draw randomness from the full domain of Fq not only Fr\n    // We use the randomness to preserve the privacy of both the sender and recipient via encryption, so a malicious\n    // sender could use non-random values to reveal the plaintext. But they already know it themselves anyway, and so\n    // the recipient already trusts them to not disclose this information. We can therefore assume that the sender will\n    // cooperate in the random value generation.\n    let randomness = unsafe { random() };\n\n    // We use the unsafe version of `fr_to_fq` because multi_scalar_mul (called by derive_public_key) will constrain\n    // the scalars.\n    let eph_sk = fr_to_fq_unsafe(randomness);\n    let eph_pk = derive_public_key(eph_sk);\n\n    (eph_sk, eph_pk)\n}\n\npub fn compute_incoming_body_ciphertext<let P: u32>(\n    plaintext: [u8; P],\n    eph_sk: Scalar,\n    address_point: AddressPoint,\n) -> [u8] {\n    let full_key = derive_aes_secret(eph_sk, address_point.to_point());\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n\n    for i in 0..16 {\n        sym_key[i] = full_key[i];\n        iv[i] = full_key[i + 16];\n    }\n    aes128_encrypt(plaintext, iv, sym_key)\n}\n\nmod test {\n    use crate::encrypted_logs::payload::{\n        compute_incoming_body_ciphertext, compute_private_log_payload,\n        MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n    };\n    use dep::protocol_types::{address::AztecAddress, point::Point, scalar::Scalar};\n    use protocol_types::public_keys::AddressPoint;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_log_payload.test.ts`\n        let contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        );\n\n        let plaintext = [\n            0, 0, 0, 1, 48, 22, 64, 206, 234, 117, 131, 145, 178, 225, 97, 201, 44, 5, 19, 241, 41,\n            2, 15, 65, 37, 37, 106, 253, 174, 38, 70, 206, 49, 9, 159, 92, 16, 244, 140, 217, 239,\n            247, 174, 91, 32, 156, 85, 124, 112, 222, 46, 101, 126, 231, 145, 102, 134, 134, 118,\n            183, 135, 233, 65, 126, 25, 38, 14, 4, 15, 228, 107, 229, 131, 183, 31, 74, 181, 183,\n            12, 38, 87, 255, 29, 5, 204, 207, 29, 41, 42, 147, 105, 98, 141, 26, 25, 79, 148, 78,\n            101, 153, 0, 0, 16, 39,\n        ];\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(\n            (MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES as u64 + 1 + 30) / 31,\n        );\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let sender = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns([69420, 1337]);\n\n        let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n        let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n        // The following value was generated by `encrypted_log_payload.test.ts`\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let private_log_payload_from_typescript = [\n            0x0e9cffc3ddd746affb02410d8f0a823e89939785bcc8e88ee4f3cae05e737c36,\n            0x008d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701f,\n            0x00a70577790aeabcc2d81ec8d0c99e7f5d2bf2f1452025dc777a178404f851d9,\n            0x003de818923f85187871d99bdf95d695eff0a900000000000000000000000000,\n            0x000000a600a61f7d59eeaf52eb51bc0592ff981d9ba3ea8e6ea8ba9dc0cec8c7,\n            0x000b81e84556a77ce6c3ca47a527f99ffe7b2524bb885a23020b7295748ad19c,\n            0x001083618ad96298b76ee07eb1a56d19cc798710e9f5de96501bd59b3781c9c0,\n            0x002a6c95c5912f8936b1500d362afbf0922c85b1ada18db8b95162a6e9d06765,\n            0x005cdf669eb387f8e0492a95fdcdb39429d5340b4bebc250ba9bf62c2f49f549,\n            0x00f37beed75a668aa51967e0e57547e5a655157bcf381e22f30e25881548ec96,\n            0x0006a151b5fbfb2d14ee4b34bf4c1dbd71c7be15ad4c63474bb6f89970aeb3d9,\n            0x00489c8edbdff80a1a3a5c28370e534abc870a85ea4318326ea19222fb10df35,\n            0x008c765edada497db4284ae30507a2e03e983d23cfa0bd831577e857bbef9cf7,\n            0x0090c97cb5699cc8783a1b4276d929be2882e5b9b72829a4f8404f7e3c853d11,\n            0x00d6d5a000b80134891e95f81007ad35d3945eaeecbe137fff85d01d7eaf8f19,\n            0x00a15eb965c6a4bc97aa87fd3463c31c9d4e0d722a8ba870bcc50c9c7a8b48ad,\n            0x0063c861bdbe490d44c57382decbae663927909652f87ac18dcfd5b30649cce5,\n            0x00820f14caa725efe1fa3485ceac88499eadf0565c5b20998c05931bbf478e68,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n\n    #[test]\n    fn test_incoming_body_ciphertext_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_note_log_incoming_body.test.ts`\n        let eph_sk = Scalar {\n            lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n            hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n        };\n        let address_point = AddressPoint {\n            inner: Point {\n                x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n                y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n                is_infinite: false,\n            },\n        };\n        let plaintext = [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,\n        ];\n\n        // `compute_incoming_body_ciphertext(...)` function then derives symmetric key from `eph_sk` and `address_point` and encrypts\n        // the note plaintext using AES-128.\n        let ciphertext = compute_incoming_body_ciphertext(plaintext, eph_sk, address_point);\n\n        // The following value was generated by `encrypted_note_log_incoming_body.test.ts`.\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let note_body_ciphertext_from_typescript = [\n            226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 147, 228, 160,\n            190, 146, 61, 95, 203, 124, 153, 68, 168, 17, 150, 92, 0, 99, 214, 85, 64, 191, 78, 157,\n            131, 149, 96, 236, 253, 96, 172, 157, 30, 27, 176, 228, 74, 242, 190, 138, 48, 33, 93,\n            46, 37, 223, 130, 25, 245, 188, 163, 159, 223, 187, 24, 139, 206, 131, 154, 159, 130,\n            37, 17, 158, 114, 242, 141, 124, 193, 232, 54, 146, 96, 145, 100, 125, 234, 57, 43, 95,\n            115, 183, 39, 121, 232, 134, 229, 148, 25, 46, 77, 87, 127, 95, 7, 77, 188, 37, 234,\n            245, 142, 232, 87, 252, 28, 67, 67, 90, 214, 254, 89, 47, 68, 66, 187, 227, 8, 59, 162,\n            25, 141, 97, 141, 217, 197, 115, 15, 212, 202, 157, 41, 150, 62, 219, 57, 224, 92, 185,\n            212, 142, 94, 146, 41, 178, 145, 68, 169, 23, 185, 206, 138, 70, 47, 176, 210, 165, 236,\n            23, 206, 229, 108,\n        ];\n\n        assert_eq(note_body_ciphertext_from_typescript.len(), ciphertext.len());\n\n        for i in 0..note_body_ciphertext_from_typescript.len() {\n            assert_eq(ciphertext[i], note_body_ciphertext_from_typescript[i]);\n        }\n    }\n}\n"
     },
-    "111": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
+    "104": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypted_note_emission.nr",
+      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::payload::compute_private_log_payload,\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n};\n\n/// Computes private note log payload\nfn compute_payload<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\n    let storage_slot = note_header.storage_slot;\n\n    // TODO(#8589): use typesystem to skip this check when not needed\n    let note_exists =\n        context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n    assert(note_exists, \"Can only emit a note log for an existing note.\");\n\n    let contract_address: AztecAddress = context.this_address();\n\n    let plaintext = note.to_be_bytes(storage_slot);\n\n    let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n    (payload, note_hash_counter)\n}\n\nunconstrained fn compute_payload_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    compute_payload(context, note, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let (encrypted_log, note_hash_counter) =\n            compute_payload(*context, e.note, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\npub fn encode_and_encrypt_note_unconstrained<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        //   Unconstrained logs have both their content and encryption unconstrained - it could occur that the\n        // recipient is unable to decrypt the payload.\n        //   Regarding the note hash counter, this is used for squashing. The kernel assumes that a given note can have\n        // more than one log and removes all of the matching ones, so all a malicious sender could do is either: cause\n        // for the log to be deleted when it shouldn't have (which is fine - they can already make the content be\n        // whatever), or cause for the log to not be deleted when it should have (which is also fine - it'll be a log\n        // for a note that doesn't exist).\n        //   It's important here that we do not\n        // return the log from this function to the app, otherwise it could try to do stuff with it and then that might\n        // be wrong.\n        let (encrypted_log, note_hash_counter) =\n            unsafe { compute_payload_unconstrained(*context, e.note, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n"
     },
-    "112": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\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    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\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    _serialized_note: [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\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            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\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_app_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_app_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 ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_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    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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"
+    "105": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr",
+      "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::note::{\n    note_emission::NoteEmission,\n    note_header::NoteHeader,\n    note_interface::{NoteInterface, NullifiableNote},\n    utils::{compute_note_hash_for_nullify_internal, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n) -> NoteEmission<Note>\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    let note_hash_counter = context.side_effect_counter;\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    let serialized_note = Note::serialize_content(*note);\n    notify_created_note(\n        storage_slot,\n        Note::get_note_type_id(),\n        serialized_note,\n        note_hash,\n        note_hash_counter,\n    );\n\n    context.push_note_hash(note_hash);\n\n    NoteEmission::new(*note)\n}\n\npub fn create_note_hash_from_public<Note, let N: u32>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    // Public note hashes are transient, but have no side effect counters, so we just need note_hash_counter != 0\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter: 1 };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    context.push_note_hash(note_hash);\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note<Note, let N: u32>(context: &mut PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n\n    destroy_note_unsafe(context, note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe<Note, let N: u32>(\n    context: &mut PrivateContext,\n    note: Note,\n    note_hash_for_read_request: Field,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_nullify =\n        compute_note_hash_for_nullify_internal(note, note_hash_for_read_request);\n    let nullifier = note.compute_nullifier(context, note_hash_for_nullify);\n\n    let note_hash_counter = note.get_header().note_hash_counter;\n    let notification_note_hash = if (note_hash_counter == 0) {\n        // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n        0\n    } else {\n        // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n        // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n        // hash with real value to inform the kernel which note we're nullifyng so that it can either squash both\n        // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n        // a siloed note hash.\n        note_hash_for_nullify\n    };\n\n    let nullifier_counter = context.side_effect_counter;\n    notify_nullified_note(nullifier, notification_note_hash, nullifier_counter);\n\n    context.push_nullifier_for_note_hash(nullifier, notification_note_hash)\n}\n"
     },
-    "114": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
-      "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
+    "108": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_getter/mod.nr",
+      "source": "use crate::context::PrivateContext;\nuse crate::note::{\n    constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n    note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::comparison::compare;\nuse dep::protocol_types::constants::{\n    GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector<let N: u32>(\n    serialized_note: [Field; N],\n    selector: PropertySelector,\n) -> Field {\n    // Selectors use PropertySelectors in order to locate note properties inside the serialized note.\n    // This allows easier packing and custom (de)serialization schemas. A note property is located\n    // inside the serialized note using the index inside the array, a byte offset and a length.\n    let value: [u8; 32] = serialized_note[selector.index].to_be_bytes();\n    let offset = selector.offset;\n    let length = selector.length;\n    let mut value_field = 0 as Field;\n    let mut acc: Field = 1;\n    for i in 0..32 {\n        if i < length {\n            value_field += value[31 + offset - i] as Field * acc;\n            acc = acc * 256;\n        }\n    }\n    value_field\n}\n\nfn check_note_header<Note, let N: u32>(context: PrivateContext, storage_slot: Field, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let header = note.get_header();\n    let contract_address = context.this_address();\n    assert(header.contract_address.eq(contract_address), \"Mismatch note header contract address.\");\n    assert(header.storage_slot == storage_slot, \"Mismatch note header storage slot.\");\n}\n\nfn check_note_fields<let N: u32>(\n    serialized_note: [Field; N],\n    selects: BoundedVec<Option<Select>, N>,\n) {\n    for i in 0..selects.len() {\n        let select = selects.get_unchecked(i).unwrap_unchecked();\n        let value_field =\n            extract_property_value_from_selector(serialized_note, select.property_selector);\n\n        assert(\n            compare(value_field, select.comparator, select.value.to_field()),\n            \"Mismatch return note field.\",\n        );\n    }\n}\n\nfn check_notes_order<let N: u32>(\n    fields_0: [Field; N],\n    fields_1: [Field; N],\n    sorts: BoundedVec<Option<Sort>, N>,\n) {\n    for i in 0..sorts.len() {\n        let sort = sorts.get_unchecked(i).unwrap_unchecked();\n        let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n        let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n        let eq = field_0 == field_1;\n        let lt = field_0.lt(field_1);\n        if sort.order == SortOrder.ASC {\n            assert(eq | lt, \"Return notes not sorted in ascending order.\");\n        } else if !eq {\n            assert(!lt, \"Return notes not sorted in descending order.\");\n        }\n    }\n}\n\npub fn get_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n) -> (Note, Field)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note = unsafe { get_note_internal(storage_slot) };\n\n    // Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do is check that\n    // the metadata is correct, and that the note exists.\n    check_note_header(*context, storage_slot, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    context.push_note_hash_read_request(note_hash_for_read_request);\n\n    (note, note_hash_for_read_request)\n}\n\npub fn get_notes<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n    // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n    // these checks correctly reject bad notes.\n    constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor<Note, PREPROCESSOR_ARGS>(\n    notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor: fn([Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n    preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    opt_notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n    // while the filter function can technically mutate the contents of the notes (as opposed to simply removing some),\n    // the private kernel will later validate that these note actually exist, so transformations would cause for that\n    // check to fail.\n    let filter_fn = options.filter;\n    let filter_args = options.filter_args;\n    let filtered_notes = filter_fn(opt_notes, filter_args);\n\n    let notes = crate::utils::array::collapse(filtered_notes);\n    let mut note_hashes: BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> =\n        BoundedVec::new();\n\n    // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n    // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n    // for the runtime length, and can therefore have fewer loop iterations.\n    assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n    let mut prev_fields = [0; N];\n    for i in 0..options.limit {\n        if i < notes.len() {\n            let note = notes.get_unchecked(i);\n            let fields = note.serialize_content();\n            check_note_header(*context, storage_slot, note);\n            check_note_fields(fields, options.selects);\n            if i != 0 {\n                check_notes_order(prev_fields, fields, options.sorts);\n            }\n            prev_fields = fields;\n\n            let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n            // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n            context.push_note_hash_read_request(note_hash_for_read_request);\n            note_hashes.push(note_hash_for_read_request);\n        };\n    }\n\n    (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal<Note, let N: u32>(storage_slot: Field) -> Note\nwhere\n    Note: NoteInterface<N>,\n{\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n    oracle::notes::get_notes(\n        storage_slot,\n        0,\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        NoteStatus.ACTIVE,\n        placeholder_note,\n        placeholder_fields,\n        placeholder_note_length,\n    )[0]\n        .expect(f\"Failed to get a note\") // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n    Note: NoteInterface<N>,\n{\n    // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let opt_notes = oracle::notes::get_notes(\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        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\npub unconstrained fn view_notes<Note, let N: u32>(\n    storage_slot: Field,\n    options: NoteViewerOptions<Note, N>,\n) -> BoundedVec<Note, MAX_NOTES_PER_PAGE>\nwhere\n    Note: NoteInterface<N>,\n{\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let notes_array = oracle::notes::get_notes(\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        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    let mut notes = BoundedVec::new();\n    for i in 0..notes_array.len() {\n        if notes_array[i].is_some() {\n            notes.push(notes_array[i].unwrap_unchecked());\n        }\n    }\n\n    notes\n}\n\nunconstrained fn flatten_options<let N: u32>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n    let mut num_selects = 0;\n    let mut select_by_indexes = [0; N];\n    let mut select_by_offsets = [0; N];\n    let mut select_by_lengths = [0; N];\n    let mut select_values = [0; N];\n    let mut select_comparators = [0; N];\n\n    for i in 0..selects.len() {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n            select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n            select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n            num_selects += 1;\n        };\n    }\n\n    let mut sort_by_indexes = [0; N];\n    let mut sort_by_offsets = [0; N];\n    let mut sort_by_lengths = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len() {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n            sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n            sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    }\n\n    (\n        num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n        select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n    )\n}\n"
+    },
+    "112": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_emission.nr",
+      "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission<Note> {\n    pub note: Note,\n}\n\nimpl<Note> NoteEmission<Note> {\n    pub fn new(note: Note) -> Self {\n        Self { note }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](Self) -> ()) {\n        _emit(self);\n    }\n\n    pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option<T>`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission<Note> {\n    emission: Option<NoteEmission<Note>>,\n}\n\nimpl<Note> OuterNoteEmission<Note> {\n    pub fn new(emission: Option<NoteEmission<Note>>) -> Self {\n        Self { emission }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](NoteEmission<Note>) -> ()) {\n        if self.emission.is_some() {\n            _emit(self.emission.unwrap());\n        }\n    }\n\n    pub fn discard(_self: Self) {}\n}\n"
     },
     "115": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
-      "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values.\n/// In some applications this behavior might not be acceptable and other techniques might be more suitable, such as\n/// producing pseudo-random values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/utils.nr",
+      "source": "use crate::{\n    context::PrivateContext,\n    note::{note_header::NoteHeader, note_interface::{NoteInterface, NullifiableNote}},\n    utils::array,\n};\n\nuse dep::protocol_types::hash::{\n    compute_siloed_note_hash, compute_siloed_nullifier as compute_siloed_nullifier_from_preimage,\n    compute_unique_note_hash,\n};\n\npub fn compute_siloed_nullifier<Note, let N: u32>(\n    note_with_header: Note,\n    context: &mut PrivateContext,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note_with_header.get_header();\n    let note_hash_for_nullify = compute_note_hash_for_nullify(note_with_header);\n    let inner_nullifier = note_with_header.compute_nullifier(context, note_hash_for_nullify);\n\n    compute_siloed_nullifier_from_preimage(header.contract_address, inner_nullifier)\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_read_request<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash = note.compute_note_hash();\n    let header = note.get_header();\n    let nonce = header.nonce;\n    let counter = header.note_hash_counter;\n\n    // If same tx note, read request always uses the normal note hash\n    if counter != 0 {\n        note_hash\n    } else {\n        // If the note comes from a different tx, we need to compute the note hash that reached the tree\n        compute_unique_note_hash(\n            nonce,\n            compute_siloed_note_hash(header.contract_address, note_hash),\n        )\n    }\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_nullify_internal<Note, let N: u32>(\n    note: Note,\n    note_hash_for_read_request: Field,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note.get_header();\n\n    if (header.note_hash_counter != 0) & (header.nonce != 0) {\n        // Non-revertible note, nullified by a revertible nullifier, we need to nullify the note hash that will reach the tree\n        let siloed_note_hash =\n            compute_siloed_note_hash(header.contract_address, note_hash_for_read_request);\n\n        compute_unique_note_hash(header.nonce, siloed_note_hash)\n    } else {\n        note_hash_for_read_request\n    }\n}\n\n// TODO(#7775): nuke this commented out code - kept it around as it contains comments which might be helpful when tackling #7775\n// pub fn compute_note_hash_for_nullify<Note, let N: u32, let M: u32>(note: Note) -> Field where Note: NoteInterface<N> {\n//     let header = note.get_header();\n//     // There are 3 cases for reading a note intended for consumption:\n//     // 1. The note was inserted in this transaction, is revertible, or is not nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce == 0)\n//     // 2. The note was inserted in this transaction, is non-revertible, and is nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce != 0)\n//     // 3. The note was inserted in a previous transaction: (note_hash_counter == 0) & (nonce != 0)\n\n//     let note_hash = note.compute_note_hiding_point().x;\n\n//     if header.nonce == 0 {\n//         // Case 1.\n//         // If a note is transient, we just read the note_hash (kernel will hash it with nonce and silo by contract address).\n//         note_hash\n//     } else {\n//         // Case 2: If a note is non-revertible, and is nullified by a revertible nullifier, we cannot squash them in the\n//         // private reset circuit. Because if the tx reverts, we will have to keep the note hash and throw away the\n//         // nullifier.\n//         // And if the tx does not revert, both will be emitted. In which case, the nullifier must be created in the app\n//         // from the siloed note hash.\n//         // The kernel circuit will check that a nullifier with non-zero note_nonce is linked to a note hash, whose\n//         // siloed note hash matches the note hash specified in the nullifier.\n\n//         // Case 3: If a note is not from the current transaction, that means we are reading a settled note (from\n//         // tree) created in a previous TX. So we need the siloed_note_hash which has already been hashed with\n//         // nonce and then contract address. This hash will match the existing leaf in the note hash\n//         // tree, so the kernel can just perform a membership check directly on this hash/leaf.\n//         let unique_note_hash = compute_unique_note_hash(header.nonce, note_hash);\n//         compute_siloed_note_hash(header.contract_address, unique_note_hash)\n//         // IMPORTANT NOTE ON REDUNDANT SILOING BY CONTRACT ADDRESS: The note hash computed above is\n//         // \"siloed\" by contract address. When a note hash is computed solely for the purpose of\n//         // nullification, it is not strictly necessary to silo the note hash before computing\n//         // its nullifier. In other words, it is NOT NECESSARY for protocol security that a nullifier\n//         // be computed from a siloed note hash. After all, persistable note hashes and nullifiers are\n//         // siloed by the kernel circuit. That being said, the siloed note hash computed above CAN be\n//         // used for nullifier computation, and this achieves the (arguably unnecessary) property that\n//         // nullifiers are computed from a note hash's fully-computed note hash tree leaf.\n//     }\n// }\n\npub fn compute_note_hash_for_nullify<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    compute_note_hash_for_nullify_internal(note, note_hash_for_read_request)\n}\n\npub unconstrained fn compute_note_hash_and_optionally_a_nullifier<T, let N: u32, let S: u32>(\n    deserialize_content: fn([Field; N]) -> T,\n    note_header: NoteHeader,\n    compute_nullifier: bool,\n    serialized_note: [Field; S],\n) -> [Field; 4]\nwhere\n    T: NoteInterface<N> + NullifiableNote,\n{\n    let mut note = deserialize_content(array::subarray(serialized_note, 0));\n    note.set_header(note_header);\n\n    let note_hash = note.compute_note_hash();\n    let siloed_note_hash = compute_siloed_note_hash(note_header.contract_address, note_hash);\n    let unique_note_hash = compute_unique_note_hash(note_header.nonce, siloed_note_hash);\n\n    let inner_nullifier = if compute_nullifier {\n        note.compute_nullifier_without_context()\n    } else {\n        0\n    };\n    // docs:start:compute_note_hash_and_optionally_a_nullifier_returns\n    [note_hash, unique_note_hash, siloed_note_hash, inner_nullifier]\n    // docs:end:compute_note_hash_and_optionally_a_nullifier_returns\n}\n"
+    },
+    "134": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/initializer.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress,\n    constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext},\n    oracle::get_contract_instance::{\n        get_contract_instance, get_contract_instance_deployer_avm,\n        get_contract_instance_initialization_hash_avm,\n    },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n    address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n    let address = context.this_address();\n    let deployer = get_contract_instance_deployer_avm(address).unwrap();\n    let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (deployer.is_zero()) | (deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n    let address = context.this_address();\n    let instance = get_contract_instance(address);\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn compute_initialization_hash(\n    init_selector: FunctionSelector,\n    init_args_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [init_selector.to_field(), init_args_hash],\n        GENERATOR_INDEX__CONSTRUCTOR,\n    )\n}\n"
     },
-    "120": {
+    "137": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "125": {
+    "139": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
+      "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values.\n/// In some applications this behavior might not be acceptable and other techniques might be more suitable, such as\n/// producing pseudo-random values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
+    },
+    "140": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/keys.nr",
       "source": "use dep::protocol_types::{\n    address::{AztecAddress, PartialAddress},\n    point::Point,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n    let result = get_public_keys_and_partial_address_oracle(address);\n\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n        ivpk_m: IvpkM {\n            inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n        },\n        ovpk_m: OvpkM {\n            inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n        },\n        tpk_m: TpkM {\n            inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(result[12]);\n\n    (keys, partial_address)\n}\n"
     },
-    "126": {
+    "142": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr",
       "source": "use dep::protocol_types::abis::validation_requests::{\n    key_validation_request::KEY_VALIDATION_REQUEST_LENGTH, KeyValidationRequest,\n};\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n    _pk_m_hash: Field,\n    _key_index: Field,\n) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {}\n\nunconstrained fn get_key_validation_request_internal(\n    npk_m_hash: Field,\n    key_index: Field,\n) -> KeyValidationRequest {\n    let result = get_key_validation_request_oracle(npk_m_hash, key_index);\n    KeyValidationRequest::deserialize(result)\n}\n\npub unconstrained fn get_key_validation_request(\n    pk_m_hash: Field,\n    key_index: Field,\n) -> KeyValidationRequest {\n    get_key_validation_request_internal(pk_m_hash, key_index)\n}\n"
     },
-    "128": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/generators.nr",
-      "source": "use dep::protocol_types::point::Point;\n\n// A set of generators generated with `derive_generators(...)` function from noir::std\npub global Ga1: Point = Point {\n    x: 0x30426e64aee30e998c13c8ceecda3a77807dbead52bc2f3bf0eae851b4b710c1,\n    y: 0x113156a068f603023240c96b4da5474667db3b8711c521c748212a15bc034ea6,\n    is_infinite: false,\n};\npub global Ga2: Point = Point {\n    x: 0x2825c79cc6a5cbbeef7d6a8f1b6a12b312aa338440aefeb4396148c89147c049,\n    y: 0x129bfd1da54b7062d6b544e7e36b90736350f6fba01228c41c72099509f5701e,\n    is_infinite: false,\n};\npub global Ga3: Point = Point {\n    x: 0x0edb1e293c3ce91bfc04e3ceaa50d2c541fa9d091c72eb403efb1cfa2cb3357f,\n    y: 0x1341d675fa030ece3113ad53ca34fd13b19b6e9762046734f414824c4d6ade35,\n    is_infinite: false,\n};\npub global Ga4: Point = Point {\n    x: 0x0e0dad2250583f2a9f0acb04ededf1701b85b0393cae753fe7e14b88af81cb52,\n    y: 0x0973b02c5caac339ee4ad5dab51329920f7bf1b6a07e1dabe5df67040b300962,\n    is_infinite: false,\n};\npub global Ga5: Point = Point {\n    x: 0x2f3342e900e8c488a28931aae68970738fdc68afde2910de7b320c00c902087d,\n    y: 0x1bf958dc63cb09d59230603a0269ae86d6f92494da244910351f1132df20fc08,\n    is_infinite: false,\n};\n// If you change this update `G_SLOT` in `yarn-project/simulator/src/client/test_utils.ts` as well\npub global G_slot: Point = Point {\n    x: 0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15,\n    y: 0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791,\n    is_infinite: false,\n};\n\nmod test {\n    use crate::generators::{G_slot, Ga1, Ga2, Ga3, Ga4, Ga5};\n    use dep::protocol_types::point::Point;\n    use std::hash::derive_generators;\n\n    #[test]\n    unconstrained fn test_generators() {\n        let generators: [Point; 6] = derive_generators(\"aztec_nr_generators\".as_bytes(), 0);\n        assert_eq(generators[0], Ga1);\n        assert_eq(generators[1], Ga2);\n        assert_eq(generators[2], Ga3);\n        assert_eq(generators[4], Ga4);\n        assert_eq(generators[5], Ga5);\n        assert_eq(generators[3], G_slot);\n    }\n}\n"
+    "145": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
+      "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
     },
-    "129": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypted_note_emission.nr",
-      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::payload::compute_private_log_payload,\n    keys::getters::get_ovsk_app,\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n    public_keys::OvpkM,\n};\n\n/// Computes private note log payload\nfn compute_payload<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    ovsk_app: Field,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\n    let storage_slot = note_header.storage_slot;\n\n    // TODO(#8589): use typesystem to skip this check when not needed\n    let note_exists =\n        context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n    assert(note_exists, \"Can only emit a note log for an existing note.\");\n\n    let contract_address: AztecAddress = context.this_address();\n\n    let plaintext = note.to_be_bytes(storage_slot);\n\n    let payload = compute_private_log_payload(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        sender,\n        plaintext,\n    );\n\n    (payload, note_hash_counter)\n}\n\nunconstrained fn compute_payload_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    let ovsk_app = get_ovsk_app(ovpk.hash());\n    compute_payload(context, note, ovsk_app, ovpk, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    // TODO: We need this because to compute a tagging secret, we require a sender. Should we have the tagging secret oracle take a ovpk_m as input instead of the address?\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, OvpkM, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let ovsk_app: Field = context.request_ovsk_app(ovpk.hash());\n\n        let (encrypted_log, note_hash_counter) =\n            compute_payload(*context, e.note, ovsk_app, ovpk, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\npub fn encode_and_encrypt_note_unconstrained<Note, let N: u32>(\n    context: &mut PrivateContext,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    // TODO: We need this because to compute a tagging secret, we require a sender. Should we have the tagging secret oracle take a ovpk_m as input instead of the address?\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, OvpkM, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        //   Unconstrained logs have both their content and encryption unconstrained - it could occur that the\n        // recipient is unable to decrypt the payload.\n        //   Regarding the note hash counter, this is used for squashing. The kernel assumes that a given note can have\n        // more than one log and removes all of the matching ones, so all a malicious sender could do is either: cause\n        // for the log to be deleted when it shouldn't have (which is fine - they can already make the content be\n        // whatever), or cause for the log to not be deleted when it should have (which is also fine - it'll be a log\n        // for a note that doesn't exist).\n        //   It's important here that we do not\n        // return the log from this function to the app, otherwise it could try to do stuff with it and then that might\n        // be wrong.\n        let (encrypted_log, note_hash_counter) =\n            unsafe { compute_payload_unconstrained(*context, e.note, ovpk, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n"
+    "148": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::CONTRACT_INSTANCE_LENGTH, contract_class_id::ContractClassId,\n    contract_instance::ContractInstance,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(\n    _address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(\n    address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n    get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n    let instance =\n        unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\n    // The to_address function combines all values in the instance object to produce an address, so by checking that we\n    // get the expected address we validate the entire struct.\n    assert_eq(instance.to_address(), address);\n\n    instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {\n    let (member, exists) = get_contract_instance_deployer_internal_avm(address);\n    if exists {\n        Option::some(AztecAddress::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {\n    let (member, exists) = get_contract_instance_class_id_internal_avm(address);\n    if exists {\n        Option::some(ContractClassId::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {\n    let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
     },
-    "130": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    point::Point,\n    public_keys::{IvpkM, ToPoint},\n    scalar::Scalar,\n};\n\nuse crate::keys::point_to_symmetric_key::point_to_symmetric_key;\n\nuse std::aes128::aes128_encrypt;\n\npub struct EncryptedLogHeader {\n    address: AztecAddress,\n}\n\nimpl EncryptedLogHeader {\n    pub fn new(address: AztecAddress) -> Self {\n        EncryptedLogHeader { address }\n    }\n\n    pub fn compute_ciphertext<T>(self, secret: Scalar, pk: T) -> [u8; 48]\n    where\n        T: ToPoint,\n    {\n        let full_key = point_to_symmetric_key(secret, pk.to_point());\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n\n        for i in 0..16 {\n            sym_key[i] = full_key[i];\n            iv[i] = full_key[i + 16];\n        }\n\n        let input: [u8; 32] = self.address.to_field().to_be_bytes();\n        aes128_encrypt(input, iv, sym_key).as_array()\n    }\n}\n\n#[test]\nunconstrained fn test_encrypted_log_header_matches_noir() {\n    let address = AztecAddress::from_field(0xdeadbeef);\n    let header = EncryptedLogHeader::new(address);\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = IvpkM {\n        inner: Point {\n            x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n            y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n            is_infinite: false,\n        },\n    };\n\n    let ciphertext = header.compute_ciphertext(secret, point);\n\n    // The following value was generated by `encrypted_log_header.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_header_ciphertext_from_typescript = [\n        226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 194, 44, 7, 131,\n        160, 83, 64, 181, 98, 38, 153, 214, 62, 171, 253, 161, 111, 191, 28, 247, 216, 26, 222, 171,\n        176, 218, 48, 209, 73, 89, 200, 209,\n    ];\n\n    assert_eq(ciphertext, expected_header_ciphertext_from_typescript);\n}\n"
+    "150": {
+      "path": "/usr/src/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    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\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    _serialized_note: [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\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::deserialize_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    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe 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"
     },
-    "132": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{GENERATOR_INDEX__SYMMETRIC_KEY, PRIVATE_LOG_SIZE_IN_FIELDS},\n    hash::{poseidon2_hash, poseidon2_hash_with_separator},\n    point::Point,\n    public_keys::{AddressPoint, OvpkM},\n    scalar::Scalar,\n    utils::arrays::array_concat,\n};\nuse std::{\n    aes128::aes128_encrypt, embedded_curve_ops::fixed_base_scalar_mul as derive_public_key,\n    field::bn254::decompose, hash::from_field_unsafe as fr_to_fq_unsafe,\n};\n\nuse crate::{\n    encrypted_logs::header::EncryptedLogHeader,\n    keys::point_to_symmetric_key::point_to_symmetric_key,\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::bytes_to_fields, point::point_to_bytes},\n};\n\n// 1 field is reserved for tag.\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n\ncomptime global HEADER_SIZE: u32 = 48;\n\ncomptime global OUTGOING_BODY_SIZE: u32 = 112;\n\n// Bytes padded to the overhead, so that the size of the incoming body ciphertext will be a multiple of 16.\ncomptime global OVERHEAD_PADDING: u32 = 15;\n\npub comptime global OVERHEAD_SIZE: u32 = 32 /* eph_pk */\n    + HEADER_SIZE /* incoming_header */\n    + HEADER_SIZE /* outgoing_header */\n    + OUTGOING_BODY_SIZE /* outgoing_body */\n    + OVERHEAD_PADDING /* padding */;\n\nglobal PLAINTEXT_LENGTH_SIZE: u32 = 2;\n\n// This is enough for 8 fields of data.\n// 1 field for storage slot, 1 field for note/event type id, allowing 6 fields for custom values.\nglobal MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n    ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\n// Note: Might have to update PRIVATE_LOG_SIZE_IN_FIELDS in `constants.nr` if the above changes.\n// This value ideally should be set by the protocol, allowing users (or `aztec-nr`) to fit data within the defined size limits.\n// Currently, we adjust this value as the structure changes, then update `constants.nr` to match.\n// Once the structure is finalized with defined overhead and max note field sizes, this value will be fixed and should remain unaffected by further payload composition changes.\n\npub fn compute_private_log_payload<let P: u32>(\n    contract_address: AztecAddress,\n    ovsk_app: Field,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n    assert(\n        P < MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n        f\"plaintext for log must not exceed {MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES}\",\n    );\n\n    let extended_plaintext: [u8; MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] = compute_encrypted_log(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        extended_plaintext,\n    );\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n    array_concat([tag], bytes_to_fields(encrypted))\n}\n\npub fn compute_partial_public_log_payload<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    ovsk_app: Field,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let extended_plaintext: [u8; P + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; M - 32] = compute_encrypted_log(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        extended_plaintext,\n    );\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n    // Silo the tag with contract address.\n    // This is done by the kernel circuit to the private logs, but since the partial log will be finalized and emitted\n    // in public as unencrypted log, its tag is not siloed at the moment.\n    // To avoid querying logs using two types of tags, we silo the tag manually here.\n    // TODO(#10273) This should be done by the AVM when it's processing the raw logs instead of their hashes.\n    let siloed_tag_bytes: [u8; 32] =\n        poseidon2_hash([contract_address.to_field(), tag]).to_be_bytes();\n\n    // Temporary hack so that the partial public log remains the same format.\n    // It should return field array and make the tag the first field as compute_private_log_payload does.\n    let mut log_bytes = [0; M];\n    for i in 0..32 {\n        log_bytes[i] = siloed_tag_bytes[i];\n    }\n    for i in 0..encrypted.len() {\n        log_bytes[i + 32] = encrypted[i];\n    }\n\n    log_bytes\n}\n\nfn compute_encrypted_log<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    ovsk_app: Field,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let header = EncryptedLogHeader::new(contract_address);\n\n    let incoming_header_ciphertext: [u8; 48] =\n        header.compute_ciphertext(eph_sk, recipient.to_address_point());\n    let outgoing_header_ciphertext: [u8; 48] = header.compute_ciphertext(eph_sk, ovpk);\n    let incoming_body_ciphertext =\n        compute_incoming_body_ciphertext(plaintext, eph_sk, recipient.to_address_point());\n    let outgoing_body_ciphertext: [u8; 112] =\n        compute_outgoing_body_ciphertext(recipient, fr_to_fq(ovsk_app), eph_sk, eph_pk);\n\n    let mut encrypted_bytes = [0; M];\n    let mut offset = 0;\n\n    // eph_pk\n    let eph_pk_bytes = point_to_bytes(eph_pk);\n    for i in 0..32 {\n        encrypted_bytes[offset + i] = eph_pk_bytes[i];\n    }\n    offset += 32;\n\n    // incoming_header\n    // outgoing_header\n    for i in 0..HEADER_SIZE {\n        encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n        encrypted_bytes[offset + HEADER_SIZE + i] = outgoing_header_ciphertext[i];\n    }\n    offset += HEADER_SIZE * 2;\n\n    // outgoing_body\n    for i in 0..OUTGOING_BODY_SIZE {\n        encrypted_bytes[offset + i] = outgoing_body_ciphertext[i];\n    }\n    offset += OUTGOING_BODY_SIZE;\n\n    // Padding.\n    offset += OVERHEAD_PADDING;\n\n    // incoming_body\n    // Then we fill in the rest as the incoming body ciphertext\n    let size = M - offset;\n    assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n    for i in 0..size {\n        encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n    }\n\n    encrypted_bytes\n}\n\n// Prepend the plaintext length as the first byte, then copy the plaintext itself starting from the second byte.\n// Fill the remaining bytes with random values to reach a fixed length of N.\nfn extend_private_log_plaintext<let P: u32, let N: u32>(plaintext: [u8; P]) -> [u8; N] {\n    let mut padded = unsafe { get_random_bytes() };\n    padded[0] = (P >> 8) as u8;\n    padded[1] = P as u8;\n    for i in 0..P {\n        padded[i + PLAINTEXT_LENGTH_SIZE] = plaintext[i];\n    }\n    padded\n}\n\nunconstrained fn get_random_bytes<let N: u32>() -> [u8; N] {\n    let mut bytes = [0; N];\n    let mut idx = 32;\n    let mut randomness = [0; 32];\n    for i in 0..N {\n        if idx == 32 {\n            randomness = random().to_be_bytes();\n            idx = 1; // Skip the first byte as it's always 0.\n        }\n        bytes[i] = randomness[idx];\n        idx += 1;\n    }\n    bytes\n}\n\n/// Converts a base field element to scalar field element.\n/// This is fine because modulus of the base field is smaller than the modulus of the scalar field.\nfn fr_to_fq(r: Field) -> Scalar {\n    let (lo, hi) = decompose(r);\n\n    Scalar { lo, hi }\n}\n\nfn generate_ephemeral_key_pair() -> (Scalar, Point) {\n    // @todo Need to draw randomness from the full domain of Fq not only Fr\n    // We use the randomness to preserve the privacy of both the sender and recipient via encryption, so a malicious\n    // sender could use non-random values to reveal the plaintext. But they already know it themselves anyway, and so\n    // the recipient already trusts them to not disclose this information. We can therefore assume that the sender will\n    // cooperate in the random value generation.\n    let randomness = unsafe { random() };\n\n    // We use the unsafe version of `fr_to_fq` because multi_scalar_mul (called by derive_public_key) will constrain\n    // the scalars.\n    let eph_sk = fr_to_fq_unsafe(randomness);\n    let eph_pk = derive_public_key(eph_sk);\n\n    (eph_sk, eph_pk)\n}\n\npub fn compute_incoming_body_ciphertext<let P: u32>(\n    plaintext: [u8; P],\n    eph_sk: Scalar,\n    address_point: AddressPoint,\n) -> [u8] {\n    let full_key = point_to_symmetric_key(eph_sk, address_point.to_point());\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n\n    for i in 0..16 {\n        sym_key[i] = full_key[i];\n        iv[i] = full_key[i + 16];\n    }\n    aes128_encrypt(plaintext, iv, sym_key)\n}\n\n/// Encrypts ephemeral secret key and recipient's address point --> with this information the recipient of outgoing will\n/// be able to derive the key with which the incoming log can be decrypted.\npub fn compute_outgoing_body_ciphertext(\n    recipient: AztecAddress,\n    ovsk_app: Scalar,\n    eph_sk: Scalar,\n    eph_pk: Point,\n) -> [u8; OUTGOING_BODY_SIZE] {\n    // Again, we could compute `eph_pk` here, but we keep the interface more similar\n    // and also make it easier to optimise it later as we just pass it along\n    let mut buffer = [0 as u8; 96];\n\n    let serialized_eph_sk_high: [u8; 32] = eph_sk.hi.to_be_bytes();\n    let serialized_eph_sk_low: [u8; 32] = eph_sk.lo.to_be_bytes();\n\n    let address_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let serialized_recipient_address_point =\n        point_to_bytes(recipient.to_address_point().to_point());\n\n    for i in 0..16 {\n        buffer[i] = serialized_eph_sk_high[i + 16];\n        buffer[i + 16] = serialized_eph_sk_low[i + 16];\n    }\n    for i in 0..32 {\n        buffer[i + 32] = address_bytes[i];\n        buffer[i + 64] = serialized_recipient_address_point[i];\n    }\n\n    // We compute the symmetric key using poseidon.\n    let full_key: [u8; 32] = poseidon2_hash_with_separator(\n        [ovsk_app.hi, ovsk_app.lo, eph_pk.x, eph_pk.y],\n        GENERATOR_INDEX__SYMMETRIC_KEY as Field,\n    )\n        .to_be_bytes();\n\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n\n    for i in 0..16 {\n        sym_key[i] = full_key[i];\n        iv[i] = full_key[i + 16];\n    }\n    aes128_encrypt(buffer, iv, sym_key).as_array()\n}\n\nmod test {\n    use crate::encrypted_logs::payload::{\n        compute_incoming_body_ciphertext, compute_outgoing_body_ciphertext,\n        compute_private_log_payload, MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n    };\n    use dep::protocol_types::{\n        address::AztecAddress, point::Point, public_keys::OvpkM, scalar::Scalar,\n    };\n    use protocol_types::public_keys::AddressPoint;\n    use std::embedded_curve_ops::fixed_base_scalar_mul as derive_public_key;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_log_payload.test.ts`\n        let contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        );\n        let ovsk_app = 0x191ac5e29bbc8f80f29ed06b75eaf30c036ed7952d844833860c527077c8c3b4;\n        let ovpk_m = OvpkM {\n            inner: Point {\n                x: 0x07f696b8b233de2c1935e43c793399586f532da5ff7c0356636a75acb862e964,\n                y: 0x156e8a3e42bfca3663936ba98c7fd26386a14657c23b5f5146f1a94b6c465154,\n                is_infinite: false,\n            },\n        };\n\n        let plaintext = [\n            0, 0, 0, 1, 48, 22, 64, 206, 234, 117, 131, 145, 178, 225, 97, 201, 44, 5, 19, 241, 41,\n            2, 15, 65, 37, 37, 106, 253, 174, 38, 70, 206, 49, 9, 159, 92, 16, 244, 140, 217, 239,\n            247, 174, 91, 32, 156, 85, 124, 112, 222, 46, 101, 126, 231, 145, 102, 134, 134, 118,\n            183, 135, 233, 65, 126, 25, 38, 14, 4, 15, 228, 107, 229, 131, 183, 31, 74, 181, 183,\n            12, 38, 87, 255, 29, 5, 204, 207, 29, 41, 42, 147, 105, 98, 141, 26, 25, 79, 148, 78,\n            101, 153, 0, 0, 16, 39,\n        ];\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(\n            (MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES as u64 + 1 + 30) / 31,\n        );\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let sender = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let _ = OracleMock::mock(\"getAppTaggingSecretAsSender\").returns([69420, 1337]);\n\n        let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n        let payload = compute_private_log_payload(\n            contract_address,\n            ovsk_app,\n            ovpk_m,\n            recipient,\n            sender,\n            plaintext,\n        );\n\n        // The following value was generated by `encrypted_log_payload.test.ts`\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let private_log_payload_from_typescript = [\n            0x0e9cffc3ddd746affb02410d8f0a823e89939785bcc8e88ee4f3cae05e737c36,\n            0x008d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701f,\n            0x00a70577790aeabcc2d81ec8d0c99e7f5d2bf2f1452025dc777a178404f851d9,\n            0x003de818923f85187871d99bdf95d695eff0a9e09ba15153fc9b4d224b6e1e71,\n            0x00dfbdcaab06c09d5b3c749bfebe1c0407eccd04f51bbb59142680c8a091b97f,\n            0x00c6cbcf615def593ab09e5b3f7f58f6fc235c90e7c77ed8dadb3b05ee4545a7,\n            0x00bc612c9139475fee6070be47efcc43a5cbbc873632f1428fac952df9c181db,\n            0x005f9e850b21fe11fedef37b88caee95111bce776e488df219732d0a77d19201,\n            0x007047186f41445ecd5c603487f7fb3c8f31010a22af69ce0000000000000000,\n            0x0000000000000000a600a61f7d59eeaf52eb51bc0592ff981d9ba3ea8e6ea8ba,\n            0x009dc0cec8c70b81e84556a77ce6c3ca47a527f99ffe7b2524bb885a23020b72,\n            0x0095748ad19c1083618ad96298b76ee07eb1a56d19cc798710e9f5de96501bd5,\n            0x009b3781c9c02a6c95c5912f8936b1500d362afbf0922c85b1ada18db8b95162,\n            0x00a6e9d067655cdf669eb387f8e0492a95fdcdb39429d5340b4bebc250ba9bf6,\n            0x002c2f49f549f37beed75a668aa51967e0e57547e5a655157bcf381e22f30e25,\n            0x00881548ec9606a151b5fbfb2d14ee4b34bf4c1dbd71c7be15ad4c63474bb6f8,\n            0x009970aeb3d9489c8edbdff80a1a3a5c28370e534abc870a85ea4318326ea192,\n            0x0022fb10df358c765edada497db4284ae30507a2e03e983d23cfa0bd831577e8,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n\n    #[test]\n    fn test_incoming_body_ciphertext_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_note_log_incoming_body.test.ts`\n        let eph_sk = Scalar {\n            lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n            hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n        };\n        let address_point = AddressPoint {\n            inner: Point {\n                x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n                y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n                is_infinite: false,\n            },\n        };\n        let plaintext = [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,\n        ];\n\n        // `compute_incoming_body_ciphertext(...)` function then derives symmetric key from `eph_sk` and `address_point` and encrypts\n        // the note plaintext using AES-128.\n        let ciphertext = compute_incoming_body_ciphertext(plaintext, eph_sk, address_point);\n\n        // The following value was generated by `encrypted_note_log_incoming_body.test.ts`.\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let note_body_ciphertext_from_typescript = [\n            226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 147, 228, 160,\n            190, 146, 61, 95, 203, 124, 153, 68, 168, 17, 150, 92, 0, 99, 214, 85, 64, 191, 78, 157,\n            131, 149, 96, 236, 253, 96, 172, 157, 30, 27, 176, 228, 74, 242, 190, 138, 48, 33, 93,\n            46, 37, 223, 130, 25, 245, 188, 163, 159, 223, 187, 24, 139, 206, 131, 154, 159, 130,\n            37, 17, 158, 114, 242, 141, 124, 193, 232, 54, 146, 96, 145, 100, 125, 234, 57, 43, 95,\n            115, 183, 39, 121, 232, 134, 229, 148, 25, 46, 77, 87, 127, 95, 7, 77, 188, 37, 234,\n            245, 142, 232, 87, 252, 28, 67, 67, 90, 214, 254, 89, 47, 68, 66, 187, 227, 8, 59, 162,\n            25, 141, 97, 141, 217, 197, 115, 15, 212, 202, 157, 41, 150, 62, 219, 57, 224, 92, 185,\n            212, 142, 94, 146, 41, 178, 145, 68, 169, 23, 185, 206, 138, 70, 47, 176, 210, 165, 236,\n            23, 206, 229, 108,\n        ];\n\n        assert_eq(note_body_ciphertext_from_typescript.len(), ciphertext.len());\n\n        for i in 0..note_body_ciphertext_from_typescript.len() {\n            assert_eq(ciphertext[i], note_body_ciphertext_from_typescript[i]);\n        }\n    }\n\n    #[test]\n    fn test_encrypted_log_outgoing_body_matches_typescript() {\n        let eph_sk = Scalar {\n            lo: 0x00000000000000000000000000000000d0d302ee245dfaf2807e604eec4715fe,\n            hi: 0x000000000000000000000000000000000f096b423017226a18461115fa8d34bb,\n        };\n\n        let sender_ovsk_app = Scalar {\n            lo: 0x0000000000000000000000000000000074d2e28c6bc5176ac02cf7c7d36a444e,\n            hi: 0x00000000000000000000000000000000089c6887cb1446d86c64e81afc78048b,\n        };\n\n        let eph_pk = derive_public_key(eph_sk);\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let ciphertext =\n            compute_outgoing_body_ciphertext(recipient, sender_ovsk_app, eph_sk, eph_pk);\n\n        // The following value was generated by `encrypted_log_payload.test.ts`\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let outgoing_body_ciphertext_from_typescript = [\n            97, 221, 53, 168, 242, 56, 217, 184, 114, 127, 137, 98, 31, 63, 86, 179, 139, 198, 162,\n            162, 216, 158, 255, 205, 90, 212, 141, 55, 9, 245, 6, 146, 202, 137, 129, 36, 190, 31,\n            17, 89, 151, 203, 43, 196, 203, 233, 178, 79, 202, 70, 250, 182, 18, 191, 79, 42, 205,\n            204, 145, 14, 13, 35, 255, 139, 142, 66, 193, 240, 175, 233, 180, 37, 153, 235, 41, 88,\n            232, 52, 235, 213, 50, 26, 153, 227, 25, 242, 161, 92, 45, 152, 100, 106, 29, 192, 131,\n            101, 121, 126, 31, 118, 191, 90, 238, 43, 24, 82, 49, 18, 199, 107, 83, 7,\n        ];\n\n        assert_eq(outgoing_body_ciphertext_from_typescript, ciphertext);\n    }\n}\n"
+    "151": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "142": {
+    "156": {
       "path": "/usr/src/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_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\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\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "144": {
+    "157": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/generators.nr",
+      "source": "use dep::protocol_types::point::Point;\n\n// A set of generators generated with `derive_generators(...)` function from noir::std\npub global Ga1: Point = Point {\n    x: 0x30426e64aee30e998c13c8ceecda3a77807dbead52bc2f3bf0eae851b4b710c1,\n    y: 0x113156a068f603023240c96b4da5474667db3b8711c521c748212a15bc034ea6,\n    is_infinite: false,\n};\npub global Ga2: Point = Point {\n    x: 0x2825c79cc6a5cbbeef7d6a8f1b6a12b312aa338440aefeb4396148c89147c049,\n    y: 0x129bfd1da54b7062d6b544e7e36b90736350f6fba01228c41c72099509f5701e,\n    is_infinite: false,\n};\npub global Ga3: Point = Point {\n    x: 0x0edb1e293c3ce91bfc04e3ceaa50d2c541fa9d091c72eb403efb1cfa2cb3357f,\n    y: 0x1341d675fa030ece3113ad53ca34fd13b19b6e9762046734f414824c4d6ade35,\n    is_infinite: false,\n};\npub global Ga4: Point = Point {\n    x: 0x0e0dad2250583f2a9f0acb04ededf1701b85b0393cae753fe7e14b88af81cb52,\n    y: 0x0973b02c5caac339ee4ad5dab51329920f7bf1b6a07e1dabe5df67040b300962,\n    is_infinite: false,\n};\npub global Ga5: Point = Point {\n    x: 0x2f3342e900e8c488a28931aae68970738fdc68afde2910de7b320c00c902087d,\n    y: 0x1bf958dc63cb09d59230603a0269ae86d6f92494da244910351f1132df20fc08,\n    is_infinite: false,\n};\n// If you change this update `G_SLOT` in `yarn-project/simulator/src/client/test_utils.ts` as well\npub global G_slot: Point = Point {\n    x: 0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15,\n    y: 0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791,\n    is_infinite: false,\n};\n\nmod test {\n    use crate::generators::{G_slot, Ga1, Ga2, Ga3, Ga4, Ga5};\n    use dep::protocol_types::point::Point;\n    use std::hash::derive_generators;\n\n    #[test]\n    unconstrained fn test_generators() {\n        let generators: [Point; 6] = derive_generators(\"aztec_nr_generators\".as_bytes(), 0);\n        assert_eq(generators[0], Ga1);\n        assert_eq(generators[1], Ga2);\n        assert_eq(generators[2], Ga3);\n        assert_eq(generators[4], Ga4);\n        assert_eq(generators[5], Ga5);\n        assert_eq(generators[3], G_slot);\n    }\n}\n"
+    },
+    "171": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr",
       "source": "use crate::{\n    keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n    oracle::{\n        key_validation_request::get_key_validation_request,\n        keys::get_public_keys_and_partial_address,\n    },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n    get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n    get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n    // Public keys are constrained by showing their inclusion in the address's preimage.\n    let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n    assert_eq(\n        account,\n        AztecAddress::compute(public_keys, partial_address),\n        \"Invalid public keys hint for address\",\n    );\n\n    public_keys\n}\n"
     },
-    "145": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/keys/point_to_symmetric_key.nr",
-      "source": "use crate::utils::point::point_to_bytes;\nuse dep::protocol_types::{\n    constants::GENERATOR_INDEX__SYMMETRIC_KEY, point::Point, scalar::Scalar, utils::arr_copy_slice,\n};\nuse std::{embedded_curve_ops::multi_scalar_mul, hash::sha256};\n\n// TODO(#5726): This function is called deriveAESSecret in TS. I don't like point_to_symmetric_key name much since\n// point is not the only input of the function. Unify naming with TS once we have a better name.\npub fn point_to_symmetric_key(secret: Scalar, point: Point) -> [u8; 32] {\n    let shared_secret: Point = multi_scalar_mul([point], [secret]);\n    let shared_secret = point_to_bytes(shared_secret);\n    let mut shared_secret_bytes_with_separator = [0 as u8; 33];\n    shared_secret_bytes_with_separator =\n        arr_copy_slice(shared_secret, shared_secret_bytes_with_separator, 0);\n    shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n    sha256(shared_secret_bytes_with_separator)\n}\n\n#[test]\nunconstrained fn test_point_to_symmetric_key_matches_noir() {\n    // Value taken from \"derive shared secret\" test in encrypt_buffer.test.ts\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = Point {\n        x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n        y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n        is_infinite: false,\n    };\n\n    let key = point_to_symmetric_key(secret, point);\n\n    // The following value was generated by `encrypt_buffer.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let key_from_typescript = [\n        251, 232, 177, 34, 2, 174, 35, 92, 165, 118, 168, 3, 153, 140, 46, 210, 203, 154, 184, 158,\n        236, 33, 95, 77, 93, 120, 72, 88, 190, 209, 64, 159,\n    ];\n    assert_eq(key, key_from_typescript);\n}\n"
-    },
-    "152": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/point.nr",
-      "source": "use dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a public key to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(pk: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!pk.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = pk.x.to_be_bytes();\n\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    if !BN254_FR_MODULUS_DIV_2.lt(pk.y) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\nmod test {\n    use crate::utils::point::point_to_bytes;\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n}\n"
-    },
-    "171": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/private_immutable.nr",
-      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize},\n};\n\nuse crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n    lifecycle::create_note,\n    note_emission::NoteEmission,\n    note_getter::{get_note, view_notes},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n};\nuse crate::oracle::notes::check_nullifier_exists;\nuse crate::state_vars::storage::Storage;\n\n// docs:start:struct\npub struct PrivateImmutable<Note, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PrivateImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<Note, Context> PrivateImmutable<Note, Context> {\n    // docs:start:new\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n    // docs:end:new\n\n    // The following computation is leaky, in that it doesn't hide the storage slot that has been initialized, nor does it hide the contract address of this contract.\n    // When this initialization nullifier is emitted, an observer could do a dictionary or rainbow attack to learn the preimage of this nullifier to deduce the storage slot and contract address.\n    // For some applications, leaking the details that a particular state variable of a particular contract has been initialized will be unacceptable.\n    // Under such circumstances, such application developers might wish to _not_ use this state variable type.\n    // This is especially dangerous for initial assignment to elements of a `Map<AztecAddress, PrivateImmutable>` type (for example), because the storage slot often also identifies an actor.\n    // e.g. the initial assignment to `my_map.at(msg.sender)` will leak: `msg.sender`, the fact that an element of `my_map` was assigned-to for the first time, and the contract_address.\n    pub fn compute_initialization_nullifier(self) -> Field {\n        poseidon2_hash_with_separator(\n            [self.storage_slot],\n            GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n        )\n    }\n}\n\nimpl<Note> PrivateImmutable<Note, &mut PrivateContext> {\n    // docs:start:initialize\n    pub fn initialize<let N: u32>(self, note: &mut Note) -> NoteEmission<Note>\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        // Nullify the storage slot.\n        let nullifier = self.compute_initialization_nullifier();\n        self.context.push_nullifier(nullifier);\n\n        create_note(self.context, self.storage_slot, note)\n    }\n    // docs:end:initialize\n\n    // docs:start:get_note\n    pub fn get_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let storage_slot = self.storage_slot;\n        get_note(self.context, storage_slot).0\n    }\n    // docs:end:get_note\n}\n\nimpl<Note> PrivateImmutable<Note, UnconstrainedContext> {\n    // docs:start:is_initialized\n    pub unconstrained fn is_initialized(self) -> bool {\n        let nullifier = self.compute_initialization_nullifier();\n        check_nullifier_exists(nullifier)\n    }\n    // docs:end:is_initialized\n\n    // view_note does not actually use the context, but it calls oracles that are only available in private\n    // docs:start:view_note\n    pub unconstrained fn view_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let mut options = NoteViewerOptions::new();\n        view_notes(self.storage_slot, options.set_limit(1)).get(0)\n    }\n    // docs:end:view_note\n}\n"
+    "173": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/keys/secret_derivation.nr",
+      "source": "use crate::utils::point::point_to_bytes;\nuse dep::protocol_types::{constants::GENERATOR_INDEX__SYMMETRIC_KEY, point::Point, scalar::Scalar};\nuse std::{embedded_curve_ops::multi_scalar_mul, hash::sha256};\n\npub fn derive_aes_secret(secret: Scalar, point: Point) -> [u8; 32] {\n    let shared_secret = point_to_bytes(multi_scalar_mul([point], [secret]));\n\n    let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n    for i in 0..shared_secret.len() {\n        shared_secret_bytes_with_separator[i] = shared_secret[i];\n    }\n\n    shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n    sha256(shared_secret_bytes_with_separator)\n}\n\n#[test]\nunconstrained fn test_derive_aes_secret_matches_noir() {\n    // Value taken from \"derive shared secret\" test in encrypt_buffer.test.ts\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = Point {\n        x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n        y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n        is_infinite: false,\n    };\n\n    let key = derive_aes_secret(secret, point);\n\n    // The following value was generated by `encrypt_buffer.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let key_from_typescript = [\n        251, 232, 177, 34, 2, 174, 35, 92, 165, 118, 168, 3, 153, 140, 46, 210, 203, 154, 184, 158,\n        236, 33, 95, 77, 93, 120, 72, 88, 190, 209, 64, 159,\n    ];\n    assert_eq(key, key_from_typescript);\n}\n"
     },
     "176": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
-      "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize<POINT_LENGTH> for Point {\n    fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n        [self.x, self.y, self.is_infinite as Field]\n    }\n}\n\nimpl Hash for Point {\n    fn hash(self) -> Field {\n        poseidon2_hash(self.serialize())\n    }\n}\n\nimpl Empty for Point {\n    /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n    /// empty/unpopulated value in an array of points).\n    fn empty() -> Self {\n        Point { x: 0, y: 0, is_infinite: false }\n    }\n}\n\nimpl Deserialize<POINT_LENGTH> for Point {\n    fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n        Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n    }\n}\n"
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
+      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "183": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
-      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
+    "178": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
+      "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nfn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 2);\n}\n\n#[test]\nfn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concated = array_concat(array0, array1);\n    assert_eq(concated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
-    "186": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/contract_instance.nr",
-      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    constants::CONTRACT_INSTANCE_LENGTH,\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize},\n};\n\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Eq for ContractInstance {\n    fn eq(self, other: Self) -> bool {\n        self.public_keys.eq(other.public_keys)\n            & self.initialization_hash.eq(other.initialization_hash)\n            & self.contract_class_id.eq(other.contract_class_id)\n            & self.salt.eq(other.salt)\n    }\n}\n\nimpl Serialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn serialize(self) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n        let public_keys_serialized = self.public_keys.serialize();\n        [\n            self.salt,\n            self.deployer.to_field(),\n            self.contract_class_id.to_field(),\n            self.initialization_hash,\n            public_keys_serialized[0],\n            public_keys_serialized[1],\n            public_keys_serialized[2],\n            public_keys_serialized[3],\n            public_keys_serialized[4],\n            public_keys_serialized[5],\n            public_keys_serialized[6],\n            public_keys_serialized[7],\n            public_keys_serialized[8],\n            public_keys_serialized[9],\n            public_keys_serialized[10],\n            public_keys_serialized[11],\n        ]\n    }\n}\n\nimpl Deserialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn deserialize(serialized: [Field; CONTRACT_INSTANCE_LENGTH]) -> Self {\n        Self {\n            salt: serialized[0],\n            deployer: AztecAddress::from_field(serialized[1]),\n            contract_class_id: ContractClassId::from_field(serialized[2]),\n            initialization_hash: serialized[3],\n            public_keys: PublicKeys::deserialize([\n                serialized[4],\n                serialized[5],\n                serialized[6],\n                serialized[7],\n                serialized[8],\n                serialized[9],\n                serialized[10],\n                serialized[11],\n                serialized[12],\n                serialized[13],\n                serialized[14],\n                serialized[15],\n            ]),\n        }\n    }\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n            ),\n        )\n    }\n}\n"
+    "196": {
+      "path": "/usr/src/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"
     },
-    "191": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
-      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
+    "206": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/abis/validation_requests/key_validation_request.nr",
+      "source": "use crate::{point::Point, traits::{Deserialize, Empty, Serialize}};\npub use crate::constants::KEY_VALIDATION_REQUEST_LENGTH;\n\npub struct KeyValidationRequest {\n    pub pk_m: Point,\n    pub sk_app: Field, // not a grumpkin scalar because it's output of poseidon2\n}\n\nimpl Eq for KeyValidationRequest {\n    fn eq(self, request: KeyValidationRequest) -> bool {\n        (request.pk_m.eq(self.pk_m)) & (request.sk_app.eq(self.sk_app))\n    }\n}\n\nimpl Empty for KeyValidationRequest {\n    fn empty() -> Self {\n        KeyValidationRequest { pk_m: Point::empty(), sk_app: 0 }\n    }\n}\n\nimpl Serialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn serialize(self) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {\n        [self.pk_m.x, self.pk_m.y, self.pk_m.is_infinite as Field, self.sk_app]\n    }\n}\n\nimpl Deserialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn deserialize(fields: [Field; KEY_VALIDATION_REQUEST_LENGTH]) -> Self {\n        Self {\n            pk_m: Point { x: fields[0], y: fields[1], is_infinite: fields[2] as bool },\n            sk_app: fields[3],\n        }\n    }\n}\n"
     },
-    "193": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
-      "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
+    "265": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr",
+      "source": "use crate::traits::{Deserialize, Serialize};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n    app_tagging_secret: Field,\n    index: u32,\n}\n\nimpl IndexedTaggingSecret {\n    pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n        poseidon2_hash(\n            [self.app_tagging_secret, recipient.to_field(), self.index as Field],\n        )\n    }\n}\n"
     },
-    "194": {
+    "268": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "195": {
+    "269": {
       "path": "/usr/src/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, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\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::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\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\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    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\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"
+      "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, TpkM},\n    traits::{Deserialize, Empty, FromField, 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::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\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\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"
     },
-    "220": {
-      "path": "/usr/src/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::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    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__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, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_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: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\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.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\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            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    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 = std::hash::sha256(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"
+    "272": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
+      "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "258": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/abis/validation_requests/key_validation_request.nr",
-      "source": "use crate::{point::Point, traits::{Deserialize, Empty, Serialize}};\npub use crate::constants::KEY_VALIDATION_REQUEST_LENGTH;\n\npub struct KeyValidationRequest {\n    pub pk_m: Point,\n    pub sk_app: Field, // not a grumpkin scalar because it's output of poseidon2\n}\n\nimpl Eq for KeyValidationRequest {\n    fn eq(self, request: KeyValidationRequest) -> bool {\n        (request.pk_m.eq(self.pk_m)) & (request.sk_app.eq(self.sk_app))\n    }\n}\n\nimpl Empty for KeyValidationRequest {\n    fn empty() -> Self {\n        KeyValidationRequest { pk_m: Point::empty(), sk_app: 0 }\n    }\n}\n\nimpl Serialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn serialize(self) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {\n        [self.pk_m.x, self.pk_m.y, self.pk_m.is_infinite as Field, self.sk_app]\n    }\n}\n\nimpl Deserialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn deserialize(fields: [Field; KEY_VALIDATION_REQUEST_LENGTH]) -> Self {\n        Self {\n            pk_m: Point { x: fields[0], y: fields[1], is_infinite: fields[2] as bool },\n            sk_app: fields[3],\n        }\n    }\n}\n"
+    "284": {
+      "path": "/usr/src/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::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    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::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 = std::hash::sha256(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\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, 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    tx_hash: 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(tx_hash, 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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_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: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\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.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\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) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\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: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\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 two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::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 two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::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 = std::hash::poseidon2::Poseidon2::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 contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_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 = std::hash::sha256(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"
     },
-    "290": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr",
-      "source": "use crate::traits::{Deserialize, Serialize};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n    secret: Field,\n    index: u32,\n}\n\nimpl IndexedTaggingSecret {\n    pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n        poseidon2_hash([self.secret, recipient.to_field(), self.index as Field])\n    }\n}\n"
+    "307": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
+      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
     "308": {
-      "path": "/usr/src/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"
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
+      "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize<POINT_LENGTH> for Point {\n    fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n        [self.x, self.y, self.is_infinite as Field]\n    }\n}\n\nimpl Hash for Point {\n    fn hash(self) -> Field {\n        poseidon2_hash(self.serialize())\n    }\n}\n\nimpl Empty for Point {\n    /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n    /// empty/unpopulated value in an array of points).\n    fn empty() -> Self {\n        Point { x: 0, y: 0, is_infinite: false }\n    }\n}\n\nimpl Deserialize<POINT_LENGTH> for Point {\n    fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n        Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n    }\n}\n"
     },
-    "310": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
-      "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
+    "311": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/contract_instance.nr",
+      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    constants::CONTRACT_INSTANCE_LENGTH,\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize},\n};\n\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Eq for ContractInstance {\n    fn eq(self, other: Self) -> bool {\n        self.public_keys.eq(other.public_keys)\n            & self.initialization_hash.eq(other.initialization_hash)\n            & self.contract_class_id.eq(other.contract_class_id)\n            & self.salt.eq(other.salt)\n    }\n}\n\nimpl Serialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn serialize(self) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n        let public_keys_serialized = self.public_keys.serialize();\n        [\n            self.salt,\n            self.deployer.to_field(),\n            self.contract_class_id.to_field(),\n            self.initialization_hash,\n            public_keys_serialized[0],\n            public_keys_serialized[1],\n            public_keys_serialized[2],\n            public_keys_serialized[3],\n            public_keys_serialized[4],\n            public_keys_serialized[5],\n            public_keys_serialized[6],\n            public_keys_serialized[7],\n            public_keys_serialized[8],\n            public_keys_serialized[9],\n            public_keys_serialized[10],\n            public_keys_serialized[11],\n        ]\n    }\n}\n\nimpl Deserialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn deserialize(serialized: [Field; CONTRACT_INSTANCE_LENGTH]) -> Self {\n        Self {\n            salt: serialized[0],\n            deployer: AztecAddress::from_field(serialized[1]),\n            contract_class_id: ContractClassId::from_field(serialized[2]),\n            initialization_hash: serialized[3],\n            public_keys: PublicKeys::deserialize([\n                serialized[4],\n                serialized[5],\n                serialized[6],\n                serialized[7],\n                serialized[8],\n                serialized[9],\n                serialized[10],\n                serialized[11],\n                serialized[12],\n                serialized[13],\n                serialized[14],\n                serialized[15],\n            ]),\n        }\n    }\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n            ),\n        )\n    }\n}\n"
     },
-    "317": {
-      "path": "/root/nargo/github.com/noir-lang/ecv0.1.2/src/lib.nr",
+    "320": {
+      "path": "/root/nargo/github.com/noir-lang/ec/v0.1.2/src/lib.nr",
       "source": "// Elliptic curve implementation\n// Overview\n// ========\n// The following three elliptic curve representations are admissible:\npub mod tecurve; // Twisted Edwards curves\npub mod swcurve; // Elliptic curves in Short Weierstrass form\npub mod montcurve; // Montgomery curves\npub mod consts; // Commonly used curve presets\n//\n// Note that Twisted Edwards and Montgomery curves are (birationally) equivalent, so that\n// they may be freely converted between one another, whereas Short Weierstrass curves are\n// more general. Diagramatically:\n//\n// tecurve == montcurve `subset` swcurve\n//\n// Each module is further divided into two submodules, 'affine' and 'curvegroup', depending\n// on the preferred coordinate representation. Affine coordinates are none other than the usual\n// two-dimensional Cartesian coordinates used in the definitions of these curves, whereas\n// 'CurveGroup' coordinates (terminology borrowed from Arkworks, whose conventions we try\n// to follow) are special coordinate systems with respect to which the group operations may be\n// implemented more efficiently, usually by means of an appropriate choice of projective coordinates.\n//\n// In each of these submodules, there is a Point struct and a Curve struct, the former\n// representing a point in the coordinate system and the latter a curve configuration.\n//\n// Points\n// ======\n// Points may be instantiated using the associated function `new`, which takes coordinates\n// as its arguments. For instance,\n//\n// `let p = swcurve::Point::new(1,1);`\n//\n// The additive identity may be constructed by a call to the associated function `zero` of no\n// arguments:\n//\n// `let zero = swcurve::Point::zero();`\n//\n// Points may be tested for equality by calling the method `eq`:\n//\n// `let pred = p.eq(zero);`\n//\n// There is also the method `is_zero` to explicitly check whether a point is the additive identity:\n//\n// `constrain pred == p.is_zero();`\n//\n// Points may be negated by calling the `negate` method and converted to CurveGroup (or affine)\n// coordinates by calling the `into_group` (resp. `into_affine`) method on them. Finally,\n// Points may be freely mapped between their respective Twisted Edwards and Montgomery\n// representations by calling the `into_montcurve` or `into_tecurve` methods. For mappings\n// between Twisted Edwards/Montgomery curves and Short Weierstrass curves, see the Curve section\n// below, as the underlying mappings are those of curves rather than ambient spaces.\n// As a rule, Points in affine (or CurveGroup) coordinates are mapped to Points in affine\n// (resp. CurveGroup) coordinates.\n//\n// Curves\n// ======\n// A curve configuration (Curve) is completely determined by the Field coefficients of its defining\n// equation (a and b in the case of swcurve, a and d in the case of tecurve, and j and k in\n// the case of montcurve) together with a generator (`gen`) in the corresponding coordinate system.\n// For example, the Baby Jubjub curve configuration as defined in ERC-2494 may be instantiated as a Twisted\n// Edwards curve in affine coordinates as follows:\n//\n// `let bjj_affine = tecurve::Curve::new(168700, 168696, tecurve::Point::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));`\n//\n// The `contains` method may be used to check whether a Point lies on a given curve:\n//\n// `constrain bjj_affine.contains(tecurve::Point::zero());`\n//\n// The elliptic curve group's addition operation is exposed as the `add` method, e.g.\n//\n// `let p = bjj_affine.add(bjj_affine.gen, bjj_affine.gen);`\n//\n// subtraction as the `subtract` method, e.g.\n//\n// `constrain tecurve::Point::zero().eq(bjj_affine.subtract(bjj_affine.gen, bjj_affine.gen));`\n//\n// scalar multiplication as the `mul` method, where the scalar is assumed to be a Field* element, e.g.\n//\n// `constrain tecurve::Point::zero().eq(bjj_affine.mul(2, tecurve::Point::zero());`\n//\n// There is a scalar multiplication method (`bit_mul`) provided where the scalar input is expected to be\n// an array of bits (little-endian convention), as well as a multi-scalar multiplication method** (`msm`)\n// which takes an array of Field elements and an array of elliptic curve points as arguments, both assumed\n// to be of the same length.\n//\n// Curve configurations may be converted between different coordinate representations by calling the `into_group`\n// and `into_affine` methods on them, e.g.\n//\n// `let bjj_curvegroup = bjj_affine.into_group();`\n//\n// Curve configurations may also be converted between different curve representations by calling the `into_swcurve`,\n// `into_montcurve` and `into_tecurve` methods subject to the relation between the curve representations mentioned\n// above. Note that it is possible to map Points from a Twisted Edwards/Montgomery curve to the corresponding\n// Short Weierstrass representation and back, and the methods to do so are exposed as `map_into_swcurve` and\n// `map_from_swcurve`, which each take one argument, the point to be mapped.\n//\n// Curve maps\n// ==========\n// There are a few different ways of mapping Field elements to elliptic curves. Here we provide the simplified\n// Shallue-van de Woestijne-Ulas and Elligator 2 methods, the former being applicable to all curve types\n// provided above subject to the constraint that the coefficients of the corresponding Short Weierstrass curve satisfies\n// a*b != 0 and the latter being applicable to Montgomery and Twisted Edwards curves subject to the constraint that\n// the coefficients of the corresponding Montgomery curve satisfy j*k != 0 and (j^2 - 4)/k^2 is non-square.\n//\n// The simplified Shallue-van de Woestijne-Ulas method is exposed as the method `swu_map` on the Curve configuration and\n// depends on two parameters, a Field element z != -1 for which g(x) - z is irreducible over Field and g(b/(z*a)) is\n// square, where g(x) = x^3 + a*x + b is the right-hand side of the defining equation of the corresponding Short\n// Weierstrass curve, and a Field element u to be mapped onto the curve. For example, in the case of bjj_affine above,\n// it may be determined using the scripts provided at <https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve> that z = 5.\n//\n// The Elligator 2 method is exposed as the method `elligator2_map` on the Curve configurations of Montgomery and\n// Twisted Edwards curves. Like the simplified SWU method above, it depends on a certain non-square element of Field,\n// but this element need not satisfy any further conditions, so it is included as the (Field-dependent) constant\n//`ZETA` below. Thus, the `elligator2_map` method depends only on one parameter, the Field element to be mapped onto\n// the curve.\n//\n// For details on all of the above in the context of hashing to elliptic curves, see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html>.\n//\n//\n// *TODO: Replace Field with Bigint.\n// **TODO: Support arrays of structs to make this work.\n// Field-dependent constant ZETA = a non-square element of Field\n// Required for Elligator 2 map\n// TODO: Replace with built-in constant.\nglobal ZETA: Field = 5;\n// Field-dependent constants for Tonelli-Shanks algorithm (see sqrt function below)\n// TODO: Possibly make this built-in.\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n// Higher-order version of scalar multiplication\n// TODO: Make this work so that the submodules' bit_mul may be defined in terms of it.\n//fn bit_mul<T,N>(add: fn(T,T) -> T, e: T, bits: [u1; N], p: T) -> T {\n//    let mut out = e;\n//    let n = bits.len();\n//\n//    for i in 0..n {\n//        out = add(\n//            add(out, out),\n//            if(bits[n - i - 1] == 0) {e} else {p});\n//    }\n//\n//    out\n//}\n// TODO: Make this built-in.\npub fn safe_inverse(x: Field) -> Field {\n    if x == 0 {\n        0\n    } else {\n        1 / x\n    }\n}\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\npub fn is_square(x: Field) -> bool {\n    let v = pow(x, 0 - 1 / 2);\n\n    v * (v - 1) == 0\n}\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\npub fn sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\nmod tests {\n    use crate::montcurve::affine::Point as MGaffine;\n    use crate::montcurve::curvegroup::Point as MG;\n    use crate::swcurve::affine::Point as SWGaffine;\n    use crate::swcurve::curvegroup::Point as SWG;\n    use crate::tecurve::affine::Curve as AffineCurve;\n    use crate::tecurve::affine::Point as Gaffine;\n    use crate::tecurve::curvegroup::Point as G;\n\n    #[test]\n    fn smoke_test() {\n        // Tests may be checked against https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve/tree/main/poc\n        // Define Baby Jubjub (ERC-2494) parameters in affine representation\n        let bjj_affine = AffineCurve::new(\n            168700,\n            168696,\n            Gaffine::new(\n                995203441582195749578291179787384436505546430278305826713579947235728471134,\n                5472060717959818805561601436314318772137091100104008585924551046643952123905,\n            ),\n        );\n        // Test addition\n        let p1_affine = Gaffine::new(\n            17777552123799933955779906779655732241715742912184938656739573121738514868268,\n            2626589144620713026669568689430873010625803728049924121243784502389097019475,\n        );\n        let p2_affine = Gaffine::new(\n            16540640123574156134436876038791482806971768689494387082833631921987005038935,\n            20819045374670962167435360035096875258406992893633759881276124905556507972311,\n        );\n\n        let p3_affine = bjj_affine.add(p1_affine, p2_affine);\n        assert(p3_affine.eq(Gaffine::new(\n            7916061937171219682591368294088513039687205273691143098332585753343424131937,\n            14035240266687799601661095864649209771790948434046947201833777492504781204499,\n        )));\n        // Test scalar multiplication\n        let p4_affine = bjj_affine.mul(2, p1_affine);\n        assert(p4_affine.eq(Gaffine::new(\n            6890855772600357754907169075114257697580319025794532037257385534741338397365,\n            4338620300185947561074059802482547481416142213883829469920100239455078257889,\n        )));\n        assert(p4_affine.eq(bjj_affine.bit_mul([0, 1], p1_affine)));\n        // Test subtraction\n        let p5_affine = bjj_affine.subtract(p3_affine, p3_affine);\n        assert(p5_affine.eq(Gaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_affine.contains(bjj_affine.gen)\n                & bjj_affine.contains(p1_affine)\n                & bjj_affine.contains(p2_affine)\n                & bjj_affine.contains(p3_affine)\n                & bjj_affine.contains(p4_affine)\n                & bjj_affine.contains(p5_affine),\n        );\n        // Test CurveGroup equivalents\n        let bjj = bjj_affine.into_group(); // Baby Jubjub\n        let p1 = p1_affine.into_group();\n        let p2 = p2_affine.into_group();\n        let p3 = p3_affine.into_group();\n        let p4 = p4_affine.into_group();\n        let p5 = p5_affine.into_group();\n        // Test addition\n        assert(p3.eq(bjj.add(p1, p2)));\n        // Test scalar multiplication\n        assert(p4.eq(bjj.mul(2, p1)));\n        assert(p4.eq(bjj.bit_mul([0, 1], p1)));\n        // Test subtraction\n        assert(G::zero().eq(bjj.subtract(p3, p3)));\n        assert(p5.eq(G::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj.contains(bjj.gen)\n                & bjj.contains(p1)\n                & bjj.contains(p2)\n                & bjj.contains(p3)\n                & bjj.contains(p4)\n                & bjj.contains(p5),\n        );\n        // Test SWCurve equivalents of the above\n        // First the affine representation\n        let bjj_swcurve_affine = bjj_affine.into_swcurve();\n\n        let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine);\n        let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine);\n        let p3_swcurve_affine = bjj_affine.map_into_swcurve(p3_affine);\n        let p4_swcurve_affine = bjj_affine.map_into_swcurve(p4_affine);\n        let p5_swcurve_affine = bjj_affine.map_into_swcurve(p5_affine);\n        // Addition\n        assert(p3_swcurve_affine.eq(bjj_swcurve_affine.add(p1_swcurve_affine, p2_swcurve_affine)));\n        // Doubling\n        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.mul(2, p1_swcurve_affine)));\n        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.bit_mul([0, 1], p1_swcurve_affine)));\n        // Subtraction\n        assert(SWGaffine::zero().eq(bjj_swcurve_affine.subtract(\n            p3_swcurve_affine,\n            p3_swcurve_affine,\n        )));\n        assert(p5_swcurve_affine.eq(SWGaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_swcurve_affine.contains(bjj_swcurve_affine.gen)\n                & bjj_swcurve_affine.contains(p1_swcurve_affine)\n                & bjj_swcurve_affine.contains(p2_swcurve_affine)\n                & bjj_swcurve_affine.contains(p3_swcurve_affine)\n                & bjj_swcurve_affine.contains(p4_swcurve_affine)\n                & bjj_swcurve_affine.contains(p5_swcurve_affine),\n        );\n        // Then the CurveGroup representation\n        let bjj_swcurve = bjj.into_swcurve();\n\n        let p1_swcurve = bjj.map_into_swcurve(p1);\n        let p2_swcurve = bjj.map_into_swcurve(p2);\n        let p3_swcurve = bjj.map_into_swcurve(p3);\n        let p4_swcurve = bjj.map_into_swcurve(p4);\n        let p5_swcurve = bjj.map_into_swcurve(p5);\n        // Addition\n        assert(p3_swcurve.eq(bjj_swcurve.add(p1_swcurve, p2_swcurve)));\n        // Doubling\n        assert(p4_swcurve.eq(bjj_swcurve.mul(2, p1_swcurve)));\n        assert(p4_swcurve.eq(bjj_swcurve.bit_mul([0, 1], p1_swcurve)));\n        // Subtraction\n        assert(SWG::zero().eq(bjj_swcurve.subtract(p3_swcurve, p3_swcurve)));\n        assert(p5_swcurve.eq(SWG::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_swcurve.contains(bjj_swcurve.gen)\n                & bjj_swcurve.contains(p1_swcurve)\n                & bjj_swcurve.contains(p2_swcurve)\n                & bjj_swcurve.contains(p3_swcurve)\n                & bjj_swcurve.contains(p4_swcurve)\n                & bjj_swcurve.contains(p5_swcurve),\n        );\n        // Test MontCurve conversions\n        // First the affine representation\n        let bjj_montcurve_affine = bjj_affine.into_montcurve();\n\n        let p1_montcurve_affine = p1_affine.into_montcurve();\n        let p2_montcurve_affine = p2_affine.into_montcurve();\n        let p3_montcurve_affine = p3_affine.into_montcurve();\n        let p4_montcurve_affine = p4_affine.into_montcurve();\n        let p5_montcurve_affine = p5_affine.into_montcurve();\n        // Addition\n        assert(p3_montcurve_affine.eq(bjj_montcurve_affine.add(\n            p1_montcurve_affine,\n            p2_montcurve_affine,\n        )));\n        // Doubling\n        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.mul(2, p1_montcurve_affine)));\n        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.bit_mul([0, 1], p1_montcurve_affine)));\n        // Subtraction\n        assert(MGaffine::zero().eq(bjj_montcurve_affine.subtract(\n            p3_montcurve_affine,\n            p3_montcurve_affine,\n        )));\n        assert(p5_montcurve_affine.eq(MGaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_montcurve_affine.contains(bjj_montcurve_affine.gen)\n                & bjj_montcurve_affine.contains(p1_montcurve_affine)\n                & bjj_montcurve_affine.contains(p2_montcurve_affine)\n                & bjj_montcurve_affine.contains(p3_montcurve_affine)\n                & bjj_montcurve_affine.contains(p4_montcurve_affine)\n                & bjj_montcurve_affine.contains(p5_montcurve_affine),\n        );\n        // Then the CurveGroup representation\n        let bjj_montcurve = bjj.into_montcurve();\n\n        let p1_montcurve = p1_montcurve_affine.into_group();\n        let p2_montcurve = p2_montcurve_affine.into_group();\n        let p3_montcurve = p3_montcurve_affine.into_group();\n        let p4_montcurve = p4_montcurve_affine.into_group();\n        let p5_montcurve = p5_montcurve_affine.into_group();\n        // Addition\n        assert(p3_montcurve.eq(bjj_montcurve.add(p1_montcurve, p2_montcurve)));\n        // Doubling\n        assert(p4_montcurve.eq(bjj_montcurve.mul(2, p1_montcurve)));\n        assert(p4_montcurve.eq(bjj_montcurve.bit_mul([0, 1], p1_montcurve)));\n        // Subtraction\n        assert(MG::zero().eq(bjj_montcurve.subtract(p3_montcurve, p3_montcurve)));\n        assert(p5_montcurve.eq(MG::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_montcurve.contains(bjj_montcurve.gen)\n                & bjj_montcurve.contains(p1_montcurve)\n                & bjj_montcurve.contains(p2_montcurve)\n                & bjj_montcurve.contains(p3_montcurve)\n                & bjj_montcurve.contains(p4_montcurve)\n                & bjj_montcurve.contains(p5_montcurve),\n        );\n        // Elligator 2 map-to-curve\n        let ell2_pt_map = bjj_affine.elligator2_map(27);\n\n        assert(ell2_pt_map.eq(MGaffine::new(\n            7972459279704486422145701269802978968072470631857513331988813812334797879121,\n            8142420778878030219043334189293412482212146646099536952861607542822144507872,\n        )\n            .into_tecurve()));\n        // SWU map-to-curve\n        let swu_pt_map = bjj_affine.swu_map(5, 27);\n\n        assert(swu_pt_map.eq(bjj_affine.map_from_swcurve(SWGaffine::new(\n            2162719247815120009132293839392097468339661471129795280520343931405114293888,\n            5341392251743377373758788728206293080122949448990104760111875914082289313973,\n        ))));\n    }\n\n}\n"
     },
-    "334": {
+    "339": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/account.nr",
       "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
     },
-    "336": {
+    "340": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
       "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
     },
-    "337": {
+    "341": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
       "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
     },
-    "340": {
+    "344": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
       "source": "#[oracle(getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/**\n * Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\n *\n * @param message_hash The hash of the message for which the `auth_witness` is to be fetched.\n * @return The `auth_witness` for the given `message_hash` as Field array.\n */\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n"
     },
-    "341": {
+    "345": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth.nr",
       "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .unpack_into();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
     },
-    "394": {
+    "402": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/ecdsa_k_account_contract/src/main.nr",
-      "source": "// Account contract that uses ECDSA signatures for authentication on the same curve as Ethereum.\n// The signing key is stored in an immutable private note and should be different from the signing key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract EcdsaKAccount {\n    use dep::aztec::{\n        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note,\n        keys::getters::get_public_keys,\n        macros::{functions::{initializer, noinitcheck, private, view}, storage::storage},\n    };\n    use dep::aztec::prelude::{PrivateContext, PrivateImmutable};\n\n    use dep::authwit::{\n        account::AccountActions,\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n\n    use dep::ecdsa_public_key_note::EcdsaPublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        public_key: PrivateImmutable<EcdsaPublicKeyNote, Context>,\n    }\n\n    // Creates a new account out of an ECDSA public key to use for signature verification\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: [u8; 32], signing_pub_key_y: [u8; 32]) {\n        let this = context.this_address();\n        // Not emitting outgoing for msg_sender here to not have to register keys for the contract through which we\n        // deploy this (typically MultiCallEntrypoint). I think it's ok here as I feel the outgoing here is not that\n        // important.\n        let mut pub_key_note = EcdsaPublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n\n        let this_ovpk_m = get_public_keys(this).ovpk_m;\n        storage.public_key.initialize(&mut pub_key_note).emit(encode_and_encrypt_note(\n            &mut context,\n            this_ovpk_m,\n            this,\n            this,\n        ));\n    }\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts\n    #[private]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[noinitcheck]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.public_key.get_note();\n\n        // Load auth witness\n        let witness: [Field; 64] = unsafe { get_auth_witness(outer_hash) };\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n\n        // Verify payload signature using Ethereum's signing scheme\n        // Note that noir expects the hash of the message/challenge as input to the ECDSA verification.\n        let outer_hash_bytes: [u8; 32] = outer_hash.to_be_bytes();\n        let hashed_message: [u8; 32] = std::hash::sha256(outer_hash_bytes);\n        std::ecdsa_secp256k1::verify_signature(\n            public_key.x,\n            public_key.y,\n            signature,\n            hashed_message,\n        )\n    }\n}\n\n"
+      "source": "// Account contract that uses ECDSA signatures for authentication on the same curve as Ethereum.\n// The signing key is stored in an immutable private note and should be different from the signing key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract EcdsaKAccount {\n    use dep::aztec::{\n        encrypted_logs::encrypted_note_emission::encode_and_encrypt_note,\n        macros::{functions::{initializer, noinitcheck, private, view}, storage::storage},\n    };\n    use dep::aztec::prelude::{PrivateContext, PrivateImmutable};\n\n    use dep::authwit::{\n        account::AccountActions,\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n\n    use dep::ecdsa_public_key_note::EcdsaPublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        public_key: PrivateImmutable<EcdsaPublicKeyNote, Context>,\n    }\n\n    // Creates a new account out of an ECDSA public key to use for signature verification\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: [u8; 32], signing_pub_key_y: [u8; 32]) {\n        let this = context.this_address();\n        let mut pub_key_note = EcdsaPublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n\n        storage.public_key.initialize(&mut pub_key_note).emit(encode_and_encrypt_note(\n            &mut context,\n            this,\n            this,\n        ));\n    }\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts\n    #[private]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[noinitcheck]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.public_key.get_note();\n\n        // Load auth witness\n        let witness: [Field; 64] = unsafe { get_auth_witness(outer_hash) };\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n\n        // Verify payload signature using Ethereum's signing scheme\n        // Note that noir expects the hash of the message/challenge as input to the ECDSA verification.\n        let outer_hash_bytes: [u8; 32] = outer_hash.to_be_bytes();\n        let hashed_message: [u8; 32] = std::hash::sha256(outer_hash_bytes);\n        std::ecdsa_secp256k1::verify_signature(\n            public_key.x,\n            public_key.y,\n            signature,\n            hashed_message,\n        )\n    }\n}\n\n"
     },
-    "395": {
+    "403": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/ecdsa_public_key_note/src/lib.nr",
       "source": "use dep::aztec::prelude::{NoteHeader, NoteInterface, NullifiableNote, PrivateContext};\n\nuse dep::aztec::{\n    note::utils::compute_note_hash_for_nullify, keys::getters::{get_nsk_app, get_public_keys},\n    protocol_types::{address::AztecAddress, constants::GENERATOR_INDEX__NOTE_NULLIFIER, hash::poseidon2_hash_with_separator},\n    macros::notes::note_custom_interface, generators::Ga1 as Gx_1, generators::Ga2 as Gx_2,\n    generators::Ga3 as Gy_1, generators::Ga4 as Gy_2, generators::Ga5 as G_owner, generators::G_slot\n};\n\nuse std::hash::from_field_unsafe;\n\nglobal ECDSA_PUBLIC_KEY_NOTE_LEN: u32 = 5;\n\n// Stores an ECDSA public key composed of two 32-byte elements\n// TODO: Do we need to include a nonce, in case we want to read/nullify/recreate with the same pubkey value?\n#[note_custom_interface]\npub struct EcdsaPublicKeyNote {\n    x: [u8; 32],\n    y: [u8; 32],\n    owner: AztecAddress,\n}\n\nimpl NoteInterface<ECDSA_PUBLIC_KEY_NOTE_LEN> for EcdsaPublicKeyNote {\n    // Cannot use the automatic serialization since x and y don't fit. Serialize the note as 5 fields where:\n    // [0] = x[0..31] (upper bound excluded)\n    // [1] = x[31]\n    // [2] = y[0..31]\n    // [3] = y[31]\n    // [4] = owner\n    fn serialize_content(self) -> [Field; ECDSA_PUBLIC_KEY_NOTE_LEN] {\n        let mut x: Field = 0;\n        let mut y: Field = 0;\n        let mut mul: Field = 1;\n\n        for i in 1..32 {\n            let byte_x: Field = self.x[31 - i] as Field;\n            x = x + (byte_x * mul);\n            let byte_y: Field = self.y[31 - i] as Field;\n            y = y + (byte_y * mul);\n            mul *= 256;\n        }\n\n        let last_x = self.x[31] as Field;\n        let last_y = self.y[31] as Field;\n\n        [x, last_x, y, last_y, self.owner.to_field()]\n    }\n\n    // Cannot use the automatic deserialization for the aforementioned reasons\n    fn deserialize_content(serialized_note: [Field; ECDSA_PUBLIC_KEY_NOTE_LEN]) -> EcdsaPublicKeyNote {\n        let mut x: [u8; 32] = [0; 32];\n        let mut y: [u8; 32] = [0; 32];\n\n        let part_x:[u8; 32] = serialized_note[0].to_be_bytes();\n        for i in 0..31 {\n            x[i] = part_x[i + 1];\n        }\n        x[31] = serialized_note[1].to_be_bytes::<32>()[31];\n\n        let part_y:[u8; 32] = serialized_note[2].to_be_bytes();\n        for i in 0..31 {\n            y[i] = part_y[i + 1];\n        }\n        y[31] = serialized_note[3].to_be_bytes::<32>()[31];\n\n        EcdsaPublicKeyNote { x, y, owner: AztecAddress::from_field(serialized_note[4]), header: NoteHeader::empty() }\n    }\n\n    fn to_be_bytes(self, storage_slot: Field) -> [u8; ECDSA_PUBLIC_KEY_NOTE_LEN * 32 + 64] {\n        let serialized_note = self.serialize_content();\n\n        let mut buffer: [u8; ECDSA_PUBLIC_KEY_NOTE_LEN * 32 + 64] = [0; ECDSA_PUBLIC_KEY_NOTE_LEN * 32 + 64];\n\n        let storage_slot_bytes: [u8; 32] = storage_slot.to_be_bytes();\n        let note_type_id_bytes: [u8; 32] = EcdsaPublicKeyNote::get_note_type_id().to_be_bytes();\n\n        for i in 0..32 {\n            buffer[i] = storage_slot_bytes[i];\n            buffer[32 + i] = note_type_id_bytes[i];\n        }\n\n        for i in 0..serialized_note.len() {\n            let bytes: [u8; 32] = serialized_note[i].to_be_bytes();\n            for j in 0..32 {\n                buffer[64 + i * 32 + j] = bytes[j];\n            }\n        }\n        buffer\n    }\n\n    fn get_note_type_id() -> Field {\n        comptime\n        {\n            let bytes = \"EcdsaPublicKeyNote\".as_bytes();\n            let hash = aztec::protocol_types::hash::poseidon2_hash_bytes(bytes);\n            let hash_bytes = hash.to_be_bytes::<4>();\n            aztec::protocol_types::utils::field::field_from_bytes(hash_bytes, true)\n        }\n    }\n\n    fn get_header(self) -> NoteHeader {\n        self.header\n    }\n\n    fn set_header(&mut self, header: NoteHeader) {\n        self.header = header;\n    }\n\n    fn compute_note_hash(self) -> Field {\n        let serialized = self.serialize_content();\n        std::embedded_curve_ops::multi_scalar_mul(\n            [Gx_1, Gx_2, Gy_1, Gy_2, G_owner, G_slot],\n            [\n            from_field_unsafe(serialized[0]),\n            from_field_unsafe(serialized[1]),\n            from_field_unsafe(serialized[2]),\n            from_field_unsafe(serialized[3]),\n            from_field_unsafe(serialized[4]),\n            from_field_unsafe(self.get_header().storage_slot)\n        ]\n        ).x\n    }\n}\n\nimpl NullifiableNote for EcdsaPublicKeyNote {\n\n    fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field {\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = context.request_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n\n    unconstrained fn compute_nullifier_without_context(self) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_nullify(self);\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = get_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n}\n\nimpl EcdsaPublicKeyNote {\n    pub fn new(x: [u8; 32], y: [u8; 32], owner: AztecAddress) -> Self {\n        EcdsaPublicKeyNote { x, y, owner, header: NoteHeader::empty() }\n    }\n}\n"
     }