@aztec/accounts 0.65.2 → 0.66.0

package/artifacts/SchnorrAccount.json

@@ -1,8 +1,203 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+d9e6d430f90682f49805eba18941129678cf1930-x8664",
+  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
   "name": "SchnorrAccount",
   "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"
+          },
+          "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": 3,
+              "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"
+      ]
+    },
+    {
+      "name": "lookup_validity",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "16954218183513903507": {
+            "error_kind": "string",
+            "string": "Attempted to read past end of BoundedVec"
+          },
+          "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"
+          },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
+          "7233212735005103307": {
+            "error_kind": "string",
+            "string": "attempt to multiply with overflow"
+          }
+        },
+        "parameters": [
+          {
+            "name": "consumer",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "inner_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "boolean"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/+1dW4hs2Vne1dXV3dXXOufMud+qT88lmDzsXfcS0U7iCAk6D6JRSTBU12UyOjmTzJwxRERboiNGDBLCQMSAeQj4IOLtwQtJMERFIY4kkSCBPARU8JI8BBQEg71n9n/q66++vWrX6b2q+8zUgqZ67/Wv/77+dd1rFYLX0tLRXyH5fxnecTKY/eQ3PFmKcsQV+uSzkCOfBeBzyZhVSi+I/1X+N9Ze+y0TTJxfzFEJZaKbJ/5O2GiVg+MpZ/7rZcDpAX+tTLbMGX+4muB5++Fx/AHR3Uqe0X+sjOWhH/1gkreW5Afw+yTQMnxlwpGzHzQ92ym6kMK/6eATiaI3j/62k/dPD++97dnn+j/71IvvPxg+zzUTLR4IrJhirOfHWN/+3N17z/f69946GDw/fOEFxlASmIMUrOuA9X29Z+6+Y8DYVh4M27uGz7/wzHN3GdtqRmzmc2tUXv3GqSjema0qhEv5/XKOdNCyJaJTypEO2nmV6KzmSAdtZt5QDia9I88Gz+QoCzmM9jq8z7GuN7LoCemvE695x54C0TN+WD9mN9PdhuC1IvLYhhuCzoagMy9cO8GkvctER+lm3UEHy6/PmU5ZlNtPfsMTJra90Ua6m/D+NOqN0V8PJm3uo95sEj9pPmi62xK8VkQe+gnmIZ0tQWdeuHaCSXuzPyvdbDroYPnNBZ0FnTcYnY0T0tk4Y/Is6CzoLOrpop4u6GSn47kfHRp+7NMFQf5jhG2Qu0Cy7XiRrRkViJ7ZAd8h/XXiNWdd3x8j7BA/rB8eI1QErxWRhzbEPKRTEXQUrvUFrtcFrs0ccS38a4Fr4V8LXPPEtfCvBa6Ffy1wPay4Fv61wLXwrwWuhxXXwr8WuBb+tcD1sOJa+NcC1zz8y+bqcW6/kPyWRbn81hUGzQLRMznwHdJfJ17z5We8zqH0uiP0avo550c/jQLhR37OCf2YLc+LPMN1IXkuAS6EPwcyIjz+b+XxXSsxWEXgZL89L+TBd6bfeG+jfdWxI+Th9etZ6wOWNzhFZ/uEdLYFnS1RrpDya3T4nat+G82y4CE/H40ikwN9NBC8shyB4DXee/7byUbqLQFnaUfIhDEB84wmv2Pd7Qh+/Opu0OD4EQT5xTLDfd4L72P8F0jveeE3fI8Ek3ZU+7kN/uKM8JdmhL8s4Dcc8FdmxH91RvhrM8JfnxH+xozwNwW8ajstbtyCPO533Ib3p9HvMPrrxKuvfsftYFJ3t4Tu4r6bfafz9PDeU8/dG76AfCOur8J7zMdkMNwWnaNn/m7hEeAV319MeX8p5f3llPdXUt5fTXl/LeX99ZT3N+i95Z2n5016vkDP3D+wOqD0GhAs28Oemde88gOPuPPODwS8KmvvXb5tfQbcq3aLcGFcc8W6iijPe+hU/0PVZYN37a1CH1Ry7FC5nRS+iim4FW0sx/0fF88uGS8IeOT1PMmIdK2s3713YUf1a3LE3zP8j/jBf/9b6YuAPwjy7/dd8sN/cyuYrOfm+3H7Yx/LctuB49mi8JsSwX9xZYzzgwlOVbd4XIg+maXOu8Ycqo5l2XfqZz6m0S4QPZMD3yH9ee07rWTUq+nusuC1IvJ4XkL17S8LOgtcZwvX5htAxgWuhU8scC18YoFr4RMLXAufWOCaL66FTyxwLXxigWsaroVPLHAtfGKBaxouXs95vew3cs1fPygdtQ5mc+Go0xznnu+faXvFD/6W4b/qB3/b8F/zg78xbZ3m4tL4ffxna/BZ12kM/t9KY5xXEpxZ1mnUfq4CPSMvGKN3iBeDv5nQj/defGr1OE7XGmqceC3UtcdUxQdVp124Zt3zhDh5HRb5ukR5aIMS5c169qrf9a3wgfcbr/rhx7m+hfrh9a1LgteKyCvQ/8rulwQdhauUI65yjrh4LzaeHbyf/IazpSa/MNw3gG5+fhANzK64d84S75NjW3Aq0jPyHcet382wv5bPFUb66myf25SH9qlS3nXI203+V/GCfaREMvI719r6vM6XLpM8qn0qBJPx2RWzVV+rTPKUc5RH8ey773iJ6FzKkQ76ovlemZ7jtJ/8hidKteFZjRWWh3tq2Y+qkMe234U8ttcdoeMHiU1/M0NsSut3vmfGfuc1yEf4f4R+53sTnOw3Odu2v0U6CYTcN4E221btR1R2Z9tWIQ/rCydlP9NFbL/S2hgvw7Ec2Ke6SXkqPpeDyfiU496nzGfuGf31YDL+++gbqnZCtXtxHYA7Nd764r33/cQz9+7CzReMcR/eYz4mhrH/026ocI0KHrTlUy1slpsPPO2Sy+wpPIrw47nuUYTSq98dnI2wEEy24kVBk6PQdZFnuCwiYhRH+EsgI8JzNC3Ru8NEKRWBk792UF/O4DvTb1zu55eOy+ar52T29Rwdw2mt7kvU6po90lrdMuQj/J9Aq/vrNNuD5Sskt5coHGW7YcVPnKk99HHmXDD2WWwvSoL3qhXeEQV4KLgqGFDTJWpIY3B+g2B0wEENE3fz0LlVNw+nJjmpLpnJFPfG9h6wS3aD8tDJjTe/Oqzdn3a56QV/NFSfILJO+BNEzKsGkzrPaiOTaVYbYQPF0y7oT9UUetZA4pQuH/1wi2Bx6pmXdW4T7C0BWw4m9byf/IYnSlHE8haCSbvdSpGvFEz6l+FRw+yTNtw3Z+AJ6+I64HPJloar4sBVdfCE7/BaOKRfpTK3ifb1jLTx09c0XDccuHZTcLE/rAneuTzm4dLJLQdvBv/5pEDcgfksdS7R/lbXY7hvJc7Dnz3HaT/5Jcev9UdRvTlsN8NWr9EctOq1Qa0dDhrNURR1olq30anXR/1GZ9Cp1Ue1dq3PMcv4QLqogzyXIrPUF6S/Hkzax0dHZpf4Yf3wsssdwWtF5OHRLJiHdO4IOgrX7RxxbeWIaztHXDseZFTHkrC/+zleIHzg4wX8HCPkPl7gnNCrmvK9TTrHPGyr0urVrqCjcFVyxHU9R1zcHz6F5evMVweeheXrajCpV7/T52GrQLZCfs45+PEUBxouv1Pj1ZjHlWDSh1Bf2AdCvncBf5zUtjKup7NuK8PyXE/PZZSxQDIhPMY/1/a46xlwuWgr/0CcjxBt5OuGoxzCKV6yyM0T61nijaf6lDneGP15xZus9lbjYitbEXlpk85I54ago3Bt54hrh+SZ/5VUYTerL7xerqRaHCe6wJWGy3VkapZ6ouio7aqndxRIOMha37mvedaOAlGLimqxj/0k62Kfb1wXzyhfCxkXMqbJeFpH28ZpP/mN+o3GqNZr1sJ2vxP1a51ep16Les1O1OwPOwdRPYrCWuPgYDg4+rcTdQ8OBr1Rs1frDXqdRrvR4WO0juHutUfN4ajXG7RH9SN8tWavG3VG9bDf7wza9Xjmtd87aB9l97vhKGoMhp3ooN9v1jqjbrfeHDi3H9Z7veGw3hq2GrVaLxqEUTc6mt3t9VvNbrc37A4Pes1ev9aP2r1Ov1sLe716vzfqHHS6/eboSEjefngMd7PR63VavXa9f9Dp1RvNWnPYjFXQGjbqB70o6naGnVY4ao7q3WZYa3VG7WgwajS70cFg2BgfLabmp2thd9AfHYyOJqYPmu1Rd9QKG61RozFoR0e8j45YbNeOyI/67caRRcLG8KB1ZI5WrdPu9/pR7f7nMFXFd6c+bHejaNCpN8Nuu1Xrjo5G++1mPRr1j9TfGw3a3V6nezAc9g/q3W5YH7W6zaM571b9iIMjdfF8lvkR+hDOIebYbvWytqNGf5149dWOqjlW1A+3o3uC14rIq8L/mId09gQdhetijri2csR1I0dct8+ojNs54rruQUb1WdQu0Zn1OD4sn6WNmVbXplVGVxsTzpYmaKktwbhh693F47pS26Sx7GXIR/jHYcPWTyc4Xcez8/GXJ5CZU93zJ6Edl66uZNDVINFPvAZ9l/Z8FA/H5dH34rR86EWebszCB4EP9sUS0EW5gmAsN8JnmeNF25jOVF/yEdABPvuyKdrMeL0q+OFjRJ/LaNOLIE+clg+9yCNtirGLbaqO11cx0uUDaBvTWSWYtPc65ak5D/XJKW/2VLGjNjjqBHcb4bDZ6YbDxjCqt9vDsFlv10e9Yat71JNuNxtH/cJ6c3jUAe6EB61Wq3vU0T/qQ9b6g/6AY3HedvH8OXm/QPpHP0aZrkA+wv9iRj/GOB6n5UMv8gyUH6PvsR+raxbUUQysJ4RH25jOKkF6LOA59wDkrw37g05nEDW7rfZBv1k/6HSOxlG1YTiIWp1WKzoaC/UPWr2jodygPuo0h7WjcVB7OBwdHA3tukcDHs/+2Ge9ob9cEHooEfxHM/rLZdBVnJYPvcgj/QXjBPuLuiYE4dlflH+hbUxnlWDSl7jv42mN5mBePqPaSpSJfcbgX87oM1i/4rR86EUe6TPHrrgCumk+g/BZ2kq0Da8/YVu5RXk4/2U0twjW8uPk2dcyrw3zeuCWH36c64HKRp7XT/qz9q88192Oyye3BD+4F0X1xbjfh3xfBvz2Ls02inaBaCH8rEeknF4dyf4Bz1moI2k+UBG6LQneq1ZYneXAE1OznuWwJYjPi06Wb5L9LHpm/9LU6M/rm+TtjHr1W8HGX5oqh3YtqKvFJMOl7sdUm0aWCB7/t/L47q8Tw6kGnb80zbpJIS73+eJx2VYArpDya3j5HdcH5IvrA27ywonFv6eJRSuH+sSy+KUowm/CxOKXSMZSCu1XiPaqoF1y0Db4by2PcX6ZJjWR9xXSidK93y9zaw98bsGKF37c5xaoTXqmHz+N3jhGqJi1Ivg5F4z9B22G/BmuavLr8g32xWn6UHVv9Q1Ehz9URBvwxxxolyWBH8u7PsKaFlf+Pae48mWIK/9VHP//LYoxJaEPy0M9rlEeyp2Qul+/7DlO+8lvOFuq8wu/7fvsH1Evw/+civSMfM96Lhp+RMgfhqC/8rk2GEP4PDXsh9iisJoMR9qYZzLyO66HWJ43Fvva0Mh+ijzwx/1rwaQ8aw46ZUFnS5Q7qTyKZ9fpEA9KR7U5rkHsg9JR7dkJFrunpNrI74TL7LGCfR/bBfajrOdqsb2qQsdZY5PpKeu5aH7Homdfv2knUgWB1i/eOT+Lfv183HL29Yv9K05Kv6anhX7HeRhzOU3T4Sxn66GtTKazFh9m7athfZ2lr+Y61AbbdO6ruc6+RTtyXw3l4g8ul0lGfuf64HKZeMByJ+0LKJ7VmIL7nrOOAdcEnS1R7qTyKJ5fb31CnjeJ037yG54stc9qrFCxmP0IYzHbPuvZt7PG6QftS/iZ8zr7+lX1wJLSr+lpVv0inTeSfmftqxncrPpFOq9X/WbVoeli1r4a+ij3T5ZEWZ7Py1f3tcwffhr99cCnL4zXE1TfCfVj/8fzttXk/6eH9374uQ899eKzzz4zemb4/I8M338wfP6F9z3zgZSTkY3GW+A95mN6C9E1OF4DKqTAoQ+pvuNSCm9BkK3viOWXHXQ2Tkhn4xTpGK4VgUv5hsGrfivOq593yMHxxLXm52csW8t8GIPRn9ean0uvceI1vzU/+rm/2ck1l6xsqQ6KNVzmf7jmo+ael4JJf90APkr07ncS51J9ff44N+vJ6bHOX07wzmstz/c4zmiWA5++XOtsAU7Dj2uBn1kev0e7p510vQL5CP+nsBb4e2QrtZapTsHmuIZtSlG8c7URxTnTYdymH47thg+fsRzCLhF9LsN7WBS+uF6qdSqOB6ouos6uEbzV5ZUUeD4R3eD/PFFIzMuvJQxZHcAYk2MduL95dRN4UjFvg3g2+M8Cz7bRm+Mo6s3VVm8K+A2ht51gMmbyXZGe9NVx6auYQV9fFPpSG+PXQJ44LR96kUd+RIb+XgK6aTZV7VJWm5rOKgTP9kWdIC7U+XmCn1YPMZ4j/CuiHqp2isflCje2I649MH7niWoTe6PS9rNskU4M/muOeo5jX1dfkHlAeNe+X4xDvIdT0XbdZWjlV1Lg0+T/hiM2+97zWgGelL74DlOD/6bDZmoviWrXmQeE3xF6y3KHqcEuB5NtrLJxWfC0KmirfV+850T1f9FHzqfQXkmBx/1hCP+fwl+2HOVx71mWfvy8/P47c/f7mtPv1QcJ7Pf/M6Pfu9qvaX7PsUr5vd/9MOM4ofazbwl+eL/6dzP2SfBClTgtH3qRJ1J9ErQb90lcNooT2/SCgEfbcDzBff/blIf1kg83nzXWGN2sscbg1xOgWWLNK459qDz+Po16jrEvrZ6fA7mz1HOMmbPWcx6bn7V6rg5s5np+RehL1fMSyBOn5UMv8px6PTeduep5gXSCuFDnXJdVe6tuxuL2dk/UZVes2XLgxm90zG+vCxyeD0evm06qILPpJMtFK2921HN10YHrQPCqgFeX7Ji+1EVLRXpmuOUU3NXgeGIcjIcvt7njoH+R8vZEOeYNy+8Fk7ztEW93BN9pvO0J3hjvkkOONDqIl/XDF1RtC/4YTyB4SMOrLifaozyD/f7EZ61uPQplcqxbIcadQNBCfpcCXe/4kJM9T7xynUVf3BP8sE5/qHRcrseS90XAc0PgKZBekO5jAMOXaT1KdOPQ89G1ueiqwzyXUmTcS+H5nRnberwn/VXdHHqRR84zYj3jth7rZ1HAc1x/VMCjbUxnlWCyjlQJlzrMDHXObb2VX0mBx0PkEP7HRVtfFjz58Cv0myLxifRLBP9TGf3KbHUafnXsFmCgy+1JUcCzXyk/rAIMXzKh2l31nZTRVP0yni+bFr/x4CWPvuOM31XBD8fvn6H4bbpKi9+XSQ93BF3UN8fvO0RXxe+qH111mee0+F1N4fmuo89rZQLAuQvvllL0hvBVgGFfxD7rnWA6bVdstPJpsdHwsfwvOmKjpza362pzq0Azrc39sMNmKo64bDatPasm/+8Ek3bi/p+inaWflGazNPkPHTbDfpYPmz0OPCl9PUY8G/yvOGxmZVBvLps9LuAfE3rbCSbtZGU966vv0teNDPr6jbPVr5QHu6G/c/uvbIrws9qU+5WPQx72gVi/PmyK41RXnOd2+eWMNt0DeeK0fOhFHmlT7JOzTV2XvMWJbarmjFSbVAmmt4eKdhVgzqfQXglms9Gn5z9W6HMbPmsf5jMPQaxwjUGrkJdlDJq1n1UJ0ttsdWYUXxygxqc4HmCfM7orKfA8PjX4P3KsK6nyeNi8tXG4xszrJH7i4Xid5CbIVQQ6QaDrmsH/maNPoOp7Cd6xT9wU8Cw36gvHgTepHO5r4IsWFG5FO+2C0fivLOj4sAuO05Rd0G4I/4WM8cR87jTWr1xzDy5fiBP7zi0Bz7aJUyVIr5MF0gniQp1zzMA6reD53COD/5Jj/QpjGn//pHDHtF9KlOK5D9U4acz46owxw7VGlUfM8KuvaLAleLWk2gjej531+0Y+3HUX8i5RHranqBNORXpGPWX9LtLVFrvqlWqLi4Jvbov/xdEWq/Ix/vcsaV6XUmjzerCfdmA8j2iy4XzeTcEP6+LbNI9ovoTziGqdm+Nq2jptkejeIrpqHtGPrprONlPVe+b5O464pOKMay/ctPbI+FFr57eC6bRRnvMptFdmlP9/HeMmP/sdxjarAk9KX2n7Hb47434Hl82qAv620NtOMGmnKuGaZjOeR1RjXZfN7utjZSz/fMa6Y5vtAk/KZlXi2eDLwHOW+XqXzXYFfFXoTc3X7xKuaTbjNZZq8pzVZgZfcdgMefJhMzU/cVPohOcnHnHYTNnAZTM19t8VetsJJu3Jc0rTbMbfmxmdrDYz+OsOmyFPPmy2Bzwpm90hng3+tsNmygYum6l1kTtCbzvBpD33CNc0m10KNK9ZbWbwjztshjz5sJlaF7spdMLrQt/jsJmygctm09bF2GaudbFpNrsSaF6z2szgI4fN/OwLG9vsMeBJ2exR4tngmw6bKRu4bKbWXB4VetsJJu35GOGaZrOrgeY1q80M/vseQpvtn6LNUKe8dmjjgCcT/uKfz60cL49jhQrhRtl5X/a0mHSBeLm/Pw509ZspulpKwWk+Zv6Aa34+xsmmTxyvPi74YX/40ZXjcr0peY/j5EcFHoN/QtB9E8Bw3XmC6Kpxsh9dNVrMcylFxsdTeH6XqDtqbhnP2HxVN4de5GmruWWskyWgi3IFweQ6dZy4fj8h4NE2vB71BOTxWF7Nb6LOs4zlEZ7nWA2+N/eYPParafslOCYb/DCjX5mtTsOvcF6H/Uq1GwifZb+Esq1rv0SBnhGXa6/ZtH1LPN9i8B84Rb9SbT3qIa2tv5fRr8xWp+FXrrUw5VeutbBp/RHTWYXg4/+rhEvNY6LOs+zvVt8M8ZzIL819HmvsV6pfpOb2uC585CFoB/Pcs6H8sAowpjP13cAu4VLtoGtfRjV5TtuXwe2gwX/sFP1qF3hSMbZKPBv8xzP61Xy+G5i9HaxCXpZ2cFfAVwGG20H0JZ4PnLUdrCbPWdtBg//UGfMr9e0k+9WnH/J2sAp5WdrBaX7F7SD61R7hmlc7+PtnzK9c7aDB/+EbrB2c5lfcDqJf8V4jtScC50+y7IlQ68o8n/SXwq9c+yfVBbe4X+JzK9PlKM4oRzGDHF8Qckzb23GR9naoi9qxLJ85aPB/C3NyH1vVONP2i+A+u/gZ5498zIPZfDzOR10V/JQI/pUUu+I82GWBx+CvCbrXSVake43o4jwYyxIATlw/53VZk3MlBf4K8WDwX3HEXj/2GjRYb+iTuKZyNUVvX3PMY1sZ1JurH3ZNwF8VerO5ZtQ7r7Mq2ijP+RTaKzPK/w2Hzdjv9pPn8ERpbDMccyh9pcWwbzps5tqvHie2met7DuRnJ5i00w1HuWukO5d8iOOaoG04dsR7Pv9c+c1VIb86//xqBlzoU7wHR+3jdfmgwX9b+OCOKM+yXnHwN01Wgzvrvv7fp+jrqHvev69onxe4mPZKCnya/P/niE9+9kGObaa+ccuyp6ywOuY5yz5Il83UeDzrPsgs3/JgHWabGZ20fgDbzODXQP6HxWabp2gz1Dvf++Y6qwHvtFZ9Zt5jXYU8H33maWc18B5rg79CY4E7oDulP95jvSvo8p4ypLtLdNXacdWLrk6+9/OG8NPT+86xGZ32XIHpTM0VXCRcs84VVJPnrHMFBv+EI/5Vofy8/Mp11o7BvzmjX81nzlz7FcbhLH6F8LP6FZ+1g37Fe/VUP9T1fcG0veo8vjb4lsOvTuP7AtRD2jz/92b0K/yWLE7Lh17kkX7l+t5fteWu7/2rAh5tYzqrBJM+x31s1V93zQGo/prqw3N/7cm599eaE32GtDW+tP7aOx6CdhDjAvuV6lOqsavLD9E2vMaHPpdlXO9a41Pj+hsCP4/rf8zhV36+FW06v8e/KvTFdeEnM/oVzh/EafnQizwzx6tZzyeZ9v2v6Uzdd8D7Y1U7iDrPsoah5kt5TqB/xvwqS4x9+iGIVxgXsviVmlfM6lfcDqJf8XrEZYHL1Q5Om4fkMwMN/nmHX/mZH2xOfJ+MfoV6SJsf+7mMfoX7yOO0fOhFnpnbQTUmc7WD0+YwTWeVYNLnzhEu1Q6izrP4FcKntYO/fMb8Ksu8868+BO0gxoUsfoXwDzo3rvzqGuXhPJ3RdK15I03Xmv8VwKXgOa4Z/MeF/205ysf47xZe+9+nXdud1+YOX5X/cMy78YRpGfIR/pOJbHh/m/0un4DPUbsXjeq9Ua/ZGwwa/R6ffR4n86F4XSlW6ycSXjZBby98+G7/qefuDV8IpqQND0IMDxrd9kG33wwHYTfq1mcRgi9jD4K8KnMYsvMhT2WQOwjyDiSvHb6D9ILgeCUIiP56MFlRcuTHeRF5UdhJXbZjZSsijwNdSdApCTrzwqUuwy4SnVkv9cbyBrclyrHPlYiH/eQ5PFlqZvU5o78eeK0Dkct+Sq98KTmWVRfGsJ+sCDrq0saHCRf7Dtoxz8W1suA9CPKPxapubjnk3hJ8pdU1xL+Voi/Mw7phtLl92hG8WTl1qaHxoi6JD3LUp8l2v+MEdJAfo18i+H+g9ned5NvPiU91mcs66WjVD+37lzStgY64/iF9v5ezh1GJ+PmPhHBM7yvkb3xhN+ahT3H7VibeMQ9tzH666dkGeBlnUfCKl08j/NczDhDnc5Fj2FADRLxAugR0Ua4gGMuN8NxWqEtQ0TYmX4XgObbiM+JCnXO8xcsUFbzhKxH8v4qBXyWYjL8bxDvKvkZ5RUHX8jDW4YXYyzTp4SmudLaIZ0x84bhqy7AechuoLhK3PPQD1AEnHtiiLmKef4vqUSBw5RmHONb4amveyHHBdOqKC3nWyRXKQ3/EC6atTqb1q9T4UrXDcdpPfsMTJo53qv+I9DnebVKcwXrgu++0RjryNJZscZ8ck7qgk2Ocig0qNnKMU32UrDHOdDFrjON2E/PUuE7FRuNH1TGuf1jHuB5hHeN+KeKM037yG54sRaoOFxy08/TxAskdBO4xcoF4Rfii4H9H6JzHjyhb2jyla16Hf40nfme4ue7GaT/5DU+WpC15TFzKUYaV/GUI1TzeCsmwmoMMlWCyHq+kyJev30cj87s14jUtPhg8tq0KPm2830gy1OKgp/HuiHnOKuP6FBn5w0+D7zpkXPIiYxT6njPw3Wc2/Nj3zAV3NLn+wrb9gTVt97QPfpdS7P7k2hjn2+jDLtUOqzbBYsBGoOdLuI/A8yVY91RbtAVyK9m43hr8O8Gnv04+vU309pPn8ERpfKkJfkihxhzbxLPBPwU880cuViYAnCo2Mw8Ij3IbPzukNyyreMd+oSrL7fw28OfChXn2vC7wqDaOZcFy3NdW/qf61az3NP/jmGrw73b43w7R20+ewxOlsf9VgCdlQ/7Qx+Df6/A/5U8u/6sIeJSbbYa+WaFyqu4E4l3ePraaodxSMFkHeG5gOYUePqO8ar6A/TfNH7EtQPhnRRuftZ3Jfd9DpzsIu6NhL4qi2iAcTtv3YH6zcjjOx7mqOK0mz7ZWwfDYBiL8i9AGfojGviVBL4Z7yQFXSPl9FYd4t3x4/F35cBK+eDgJb7TXDyd5tLwNyCsRnc3kGfWFuIyPEsF/BPoJcVqDMla+IuivEf1jfIt3vJ66IeA3BHxsn18gv0XZ816nf5Um4cd3zNtLMK+Xd71qNHvtfq8dRd1GNGxEzWn1Km/6rUYr6nR6nX6rP+o2+gfzpt8YtXutUTts1gaNYW3Qe5D9VJ7GI6HntZXI85xqXe1DMF3Fvy9TfwHngIuiLPfbDf4PIB5/ksYkec43qrUYnkcv+9Flg+dsA5CHx5U5086818norweT/Za8YyjSM37QpnHi+TNP6+73DypQ60brgp940/p2MGkz1QdVaz3Kf7mPOOs+KCzP8+RoY9f8Oq+Lqfl11b+1+rQRuPcAFUgPaXGC15IM/o8hTvwTxQm1H0qtr3KcYB/HPLQtx4ktKrefPIcnS/d9cXuKjrZIRwb/F47xnPJv1yUQav5BrZWavtSYze/8y3jPzM4UfaXNv/zVjPMvrnWWafMvrC81/8L82rOKLfPyxWm6ZV80+L8TulX7DsogT5yWD73I01T7DnCMXwK6afUF4bPY37W3AOdGeB4CYzbHc6S7SXlqXK9itsU2jKWutgftzfNrap0lSzz/Z8f8xLQ+Z97jiFqn0+rWDsJGe9AfDRpTv8v4fxAiFAD2bQEA",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "lookup_validity"
+      ]
+    },
+    {
+      "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": "ndLRCoMgFAbgdznXXUzTmb1KjLCyEMTCbDCid59GG210ozcHf/E73vwrdLJZhlqZfpyhrFbQYyucGo1P65ZBY5XWaqjP13ALA6H9/TwJE+LshHVQYoIykKYLJ+59r7SEkmC2PTJAOJ7k8YTEExpN8OUvnNDbYThh7IsQwjuiKeieglgKKhJQftkDTnP+QZQWv2jz8SmsEo2WR8/6xbSn2rnXJP8aONmxld1iZejiqYZ+VohlGPu1fvUb",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "verify_private_authwit",
       "is_unconstrained": false,
@@ -822,7 +1017,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -1006,7 +1201,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -1121,36 +1316,33 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
-                        "name": "counter",
+                        "name": "note_hash_counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -1158,13 +1350,7 @@
                         }
                       },
                       {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "note_hash_counter",
+                        "name": "counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -1173,15 +1359,15 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
               {
-                "name": "encrypted_logs_hashes",
+                "name": "contract_class_logs_hashes",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 1,
                   "type": {
                     "fields": [
                       {
@@ -1203,50 +1389,27 @@
                         "type": {
                           "kind": "field"
                         }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
                   }
                 }
               },
               {
-                "name": "contract_class_logs_hashes",
+                "name": "start_side_effect_counter",
                 "type": {
-                  "kind": "array",
-                  "length": 1,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
-                  }
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
                 }
               },
               {
@@ -1636,8 +1799,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",
@@ -1647,8 +1810,8 @@
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "AAAAAAABAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAUAvPb0jRI4Ytf1JK0hKPvJbnj47pCL1k+3yKQY2ytCRVM43W9hHtxwvUERUUnqVu4fNyhAKUrAUujouaaX5sG5pAAAAAAAAAAAAB8EMOakuPWXZ/uSUL3ZkmleRYMVilqpUAoQtauP/yLYJt9Ge+KFy1AiPvwmf8tYbortnuczYSgHZCLUIjrhHyEuypDbUrz8nAJECkxZdES1Q6OANFe8IrVxJLHOyqDF+hAJ2px9iohjRmgPB7ODjXPnFtKD8zk1RuVe6qRsF5ryGOBXpxDnKcL/oe3PXZ2LM6bn7gB9th4vQN4qI3EavOsoqGIhQdsKugcexyNvxa+KdM7cq7dq4NVJC/vK52z8ighEvcETJKRDr/94+LBAspGrJ4uAM5tjvQSH6lijV1k3IL9TkOG+jPkVeueCI8nMTLavu2nhIlTGYBT8X6YSFIAXLcbM3Wq4jVtyhwMjurF97zRnchC1JO8R3Lj9EYSsISlxolfRkD4tkG10soF/QFuvpu6t6kRIu23WlgFAAQAPEfvB6DiDRg3CT8K2HNVdyYXxpqEZjyjwPnbUrwbgHSspY+T8nxsAU179zd+f7hvrEcIYDERjIlTMt5i7n5539RDe70ykHLHorwEk7Vt7LL1FQKEgBE0bOOUhXLons8aEJDdrAFeveIQkYoKrr09Bmwkt3S71B9epOPeVnWKQ/zwbXLMecfTWL4iqHVAfhQYOe8aglA08U8mv+LE9UkvxuSY9vBnzYOW1rqmsldCkyd9fOqhOgRtlkFFj+1BL5Z7vBPKzHApQD2ZUgcGw0jy0dnlLcRzNx9FVO6191zyHHl8aQPyS5JHHTpm44ZhQwcpdA7cbU/j+36pYxe2OeZXaYRgDRUXrfO+FNFQu3jxv8PIKDXjDsS3RIc1F2ljfv4XpKktjRXuqS/fyOnPWaMWVlURNQh6vi/1JZBxLV/1bhAEJB3hZZS0XrZQVazV8SR+JGGgzPKMp3u9yTgytodV8/Afso2Y/b1HA19i5jy4CjdtaC38wWe79hWf3OnWm+AskGRniTuXaVhj/Jozb+53QOlQmZ0s5aZwgnGaDJX9R+3sZzAB5O1h5lFx5sFdmL08lS0218HVh+p6IbZ/gzcIjmSVZPdATsDCSDzZeix4ftjhIbT8+RjrrX8Gy/JIEYIhiJbWMY5pFddZxZAA0EUQJ2tvU/tYWok0ljEXSMrNmkLEtvYPed/ZG49D5DBzGUXRREHsjWXmgHp/0DNr68zlXUhWtloAJi3BaQB1Rt6mM1WaBnphs+zBEdYQ9ttjCwQtCI/dvgTqPACqlPG72jglzYiWWJffsSh/2oP3p+1ZY5o4K/nkc/6OWmxw8ndFWnTnDntUmUBilbJZf5F+nCw7csSC6711EatbSGVURwAJ+Xda/HjHmx7yOH+V3q3Zrw+HIIBU8fkNeQ5RTQvlX4rNIM42Irq5578vAezqR+Qx9PIkhmwONGv4FPXDMMl+xNT3ePuSnDHQasI5QWyJVxuZqLhq920dalJ4L+XbivLA6XAoZr/mQGV4VHxVKT6Pex9mMI5GSBHRHBAnjWySYrsZXvJ40cQvQ4nsQpKL+gV4oVWQSmPSR+BFbUqKJ7PngdP94gyyTTWse3ysNbZG7NnLtwhcEQ04yzpY3zENN4JDnp2ZhvZMH8C0DpFW2z/1tXLbyGh1d8hUcUZL6OKwCDhCfEOg+p3YRtXS+cZD8BvbAF74nBkigy4BT26asaHekoY//w9FQTFXcv/6AAcy4V9Lyxio+f5f0339MX0jBqFpCGx2/8xsCm37PKJvyVdkzekr5Lr3FfezIDtuofmZ7WNzRwtSRG4EA3udnySkH3J++xC8Fxi0O5qWN1Y+Jac68oN7mRtNFXVPN4H9yeifEo1VaYRrf5BEHFx3jjNugmCNBKAMAY3JtOSVgmgNJOnWHGLYIGq0E1NJNJzbPrp/auNOvsGcS0LwuAt9l+JhV6jhxbfQKaOByXqfAmUicnoJ3HEJELquO7W/A9pW25Jgo0Mv88C+9QUTgP6lQzqJfHVn4ZvE8IJquqSB3tupvUqUInWS8Dw+m/2Z5zpSothZoP8SbrILjLf6XG6FmoLjpXg3NrjMOVZ0bAx6fdK9JcAY+YJw4ABanm2Uq1mvSw/ka/Ig/qAV18BtvxADiQtufzfvhzvUdELNC9WuIHtcxfuLIjONbGgh72G92Dqv1kb3SPj8vk0LArHPX1nt5MLVct55nvekm7NVzHT+ovK6i2w+TcLH0ShQnBgFpwp2Itq1MG/IqlAxZg9EJ6LVgKHL+2pBWTKGSJJhV9M6yb28/h/cP8h54AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhoZlErJrMKfTF4lRPkiRcBHfBlf239qBoUJ2j5Z7KmhGMbxkA+6OjUxyjlhaZ1LHnR2zvWI3wJ/jrPAnkKwgfUPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvFFZ+LD6E/B4+adgfbOWAjKmgRRlkp7urvZ42nbdVYlMDeJJvFQwwx2CWXfRprm7WCcWf7s+JnyuVr/UZu/P7PA==",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-ec73737d9ef68615a07691568ea01334-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-d8b5061ac8038f0647c20c6e54063699-mega-honk-true"
     },
     {
       "name": "constructor",
@@ -1691,10 +1854,25 @@
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
           },
+          "3151558035338938026": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            ],
+            "length": 75
+          },
           "5019202896831570965": {
             "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"
@@ -2490,7 +2668,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -2674,7 +2852,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -2789,46 +2967,29 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
@@ -2838,25 +2999,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
-                  }
-                }
-              },
-              {
-                "name": "encrypted_logs_hashes",
-                "type": {
-                  "kind": "array",
-                  "length": 4,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
                       },
                       {
                         "name": "counter",
@@ -2865,22 +3007,10 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
@@ -2917,6 +3047,22 @@
                   }
                 }
               },
+              {
+                "name": "start_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
               {
                 "name": "historical_header",
                 "type": {
@@ -3304,8 +3450,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_contract_instance_internal",
         "decompose_hint",
@@ -3318,105 +3464,14 @@
         "field_less_than",
         "build_msg_block",
         "attach_len_to_msg_block",
-        "get_app_tag_bytes_as_sender",
+        "get_app_tag_as_sender",
         "increment_app_tagging_secret_index_as_sender_wrapper",
-        "build_msg_block",
-        "emit_encrypted_note_log_oracle_wrapper",
         "directive_integer_quotient",
         "directive_invert",
         "directive_to_radix"
       ],
-      "verification_key": "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",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-837ae7ef1a223f3cb737ee129d84e1d5-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": "ndLBCoQgEAbgd5lzh7Ss7FViCSsLQTTMFpbo3VejXdqli14GR+abufwbDLxbp1aoUS9QNxtI3TMrtHLdtifQGSGlmNrrN6S+IHTMLzNTvl0sMxZqnKMEuBr8izo/CsmhznG6PxJAOJxk4SQPJySY4NsrlODqNJQQ8kUIowORGFTEoDIGVREou80BLVD5QUVW/KLdtU9mBOskP3M2rqq/xM6+Zv6XwNnong+r4T6Llxi62rhbGLu1bvUb",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "lookup_validity",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "16954218183513903507": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "7233212735005103307": {
-            "error_kind": "string",
-            "string": "attempt to multiply with overflow"
-          }
-        },
-        "parameters": [
-          {
-            "name": "consumer",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "inner_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "boolean"
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "H4sIAAAAAAAA/+1dTYgkyXWO7Orq7qrumqrZ2Z2/7pnpmV3twaxxVU/1H+jQa3kPAmvtg5EOAuOe7h7N4NWMmOlFtnVphDG++GB8sA8Gg4xtjMHYBmNkMOiw+AcMPsjgmw5rMBZCAknoIiGhyZ18U19/+WVUZFdGdfcoA5rqjHj53ov3XryIeBEZkbjnaebZX5L9Pwt5nAxmJ/vtT5YGFeLqx+QzqZDPBPicMWaV0BPxvyrvzD3/bRFMWt6oUAgtolsl/q3+cKPljqeK+b/bApwR8K+1SJcV4+/PZ3g+cXQcvyO6newZ7cfesTK0o1/Kyhaycge/7wAtw9ciHBXbwXpkPQ0uFfBvMnDN5/8vPfu7kOV/7uDwF997vPeb777/+XsHT7hlosadwIopxfrKCOsnHj86fLK7d/j2/v6Tg6dPGUNTYHYFWNuA9cHuw0ef3GdscyfD9umDJ08fPn7E2OYDsZnNLdD76jdNDZFnuuoRLmX3sxXSQc02iU6zQjqo53miM18hHdSZWUPL5a2jyg7P6tES9TDabcivsK0PQ+SE9NvEa9W+JyF6xg/Lx/RmslsUvPZEGetwUdBZFHSmhYv1naad7Lc/YeoIntjOliD/NOzM6LeFjGLY2RLxU6Qzk11H8NoTZdhesQzpdASdaeFS+k7TTvbbnzC1BO0qx3qmjwtQb7blbhTa64NQWzb6beI1li13iR+WD9tyT/DaE2VoI1iGdHqCjsLVrnG9FLg6FeKq7avGVdtXjWuauGr7qnHV9lXjOq+4avuqcdX2VeM6r7hq+6px1fZV4zqvuGr7qnFNw766Lm8jF4iOWsNa8tDB9w2uI95Lst+46yn76wnRs3pgHtJvC5lMaz1FydXk04sjn2GIPSG/psuLosxw2Q6bJuBC+B7UEeHxf3sf876T/fYETm4fF12+Pphn8k3Xxv+f6oa6SQp+DS/ncXtA2VjbsHbXE2Unbd/4vsHFtZ3BgG0BUyLyGgLGeEv3FM1lG3E6As5NpU77w5aoUzW4n+/hZHtPIuC/FEU2I9/1qjuu08Tp/TMG/1pJ+Msl4a8I+EUP/NWS+K+VhL9eEn65JPxKSfgbAl71Ndaeb0IZ99O3IP80+mmj3yZeY9n6LZeX3U0hu1Seti/ycweH7z4+PHiKfCOu/4Z8LMdkMOjz2S+lz7xP7FXgFfNfK8i/XJB/pSD/akH+tYL86wX5ywX5K5RvZZfouUPPr9Bzj/BaG1BydQTL+rBn5rWqchcRd9XlTsCrdy3fZ9tWpvY2qjZm8L59dWgbNs7C/aRL9B6O83nfqcKtaON7vKfQx7Ovjmr8h7xeojoiXR7/RZrLrKmxmHNxx0sV8r9r+F+Ng//FtxSvxcG/1XH59me2n/YLN5JRPvp6nJfhuzhvQ/iN2RHO1Qynals211E2yfMb1U58+5nxfYML2XMcZ1/kcDMhes7p8YrRn9ae4wvET5Fcea6L76q5K8+vVfyiK+jUuM4Wrs7PQB1rXLVN1Lhqm6hx1TZR46ptosY1XVy1TdS4apuocY3DVdtEjau2iRrXOFy8nqNiwQmVIZ0LHjoqRu37/p9/jQ7nTRq/PikdtQ4Wd49df4P3zFSMf9PwX46D/8Wenytx8N8dt07zQTLKT/9sjT10ncbgf6UxwvlvGU5rM7hOw/vQcH2Q29Oi4EWdU9Ik+P/M6Kd7IlrN4zh9a6hp4rVQ1aaRZ/YPvnWnCyVpK7+FOHkdFvnqUhnqYJ7K8GyokLOu4q5v9YP34/D6VjMOP971LZTPSde3Evp/kv6qVSGu+Qpx8Z5iPNtsJ/vtl0vrnBG3Lxhsml5xz58lK7taID9ODXpGvlO/tRSwH5XPV0P6PI5I/79GZaif61SG+ypsv5TyF2xv81RHzmMbUX4p9vl3LaqP6p8Sl/fPPp+txlotqk+rwvoonmOPHbtEp1shHbTFoj3kadrJfvsTpbWDs+orrOwalLEdXYcy1v0ylLG+VoSMT+KbfqGEbyoady7OjPKRn6JxJ+4fQvgtGHdeyHBG/vbgTOk2VH/4rcOXSugPx1Tctyj/3HJ5/1Th3qfgM+qMftvl/X+MsaHqJ1S/R2cLv/3+4YPPPDx8BCcAM8YdyMdyTAxj/xedIhxyMmuk3WvBGuTRfeyTWUNnZ3EjGsN+4vK9a0PQZO/g+6LLvDd6V/WF3YzL94q4679JeW9lQlFfevLXAaFflaXvvZk9dAUuHnHOCbxzAq8aORlcR7w36YhG8RzZO/bH9brr1OuanRT1ui0oR/hl6HW3SFehJ01XVu9B2EnTcfzZ2rn3ZxezP+4v5gTvqw4yixqfz2lGUoLXac57+IkzRBz2L2aySfGqTziKBMxOHvkz5SinOEv1wqPwd05Wp7ucEVeH5YfV6vIFS2oIbHyXDa+gQ+MhMDZiDq+g3jm8gnbA4RWUL4fgyi4x4fvTChP4wsvnOVwUO4wzraU5sz3+RCtNO9lvf6K0dj/uILm8r2Dbxyk42xFOwVn3OAVnfa0IGYf6JpNTaHgl7ud1Z1++vgttlHxNTmXlG2XAeg7ki0uRnJR8TU61fEdl6HM5jZNhmRAd6srqdNb8Q9mxGrbXMmO1OSELNY7jsRr2wzxWQz3yWA3rxQGPWaoj5/kCBtO62mqO6oM88NizbKBFBQJiB1pe1jFhi57TtJP99idLm2fVVyhfzHaEvph1j76Y9bUiZHwS31Smr4vz+fXZl69qB5aUfE1OZeWLdH6W5Ft2rGZwZeWLdF5W+YbK0GRRdqyGNmp16rq8fBfoPdX/xx1Dr+2H9F9Iv028VsvPKLCtxiFqXJX66dXs/2dLrb/8+Ivvvv/eew/vPzx48qmD9DbXpw8efqFg8dVovAX5WI7pLaJrcPycFMA1BFxoHQ1exdHQLnirKL7P7UKNzXjbXsW2th1qa0a/7WLa/sjWfHJ1Lr+esBBHPlsJ4Ud+FoR81LyGx/NqezXCL0AdER7/t/cx75u0KIw4+dOM0O11qcz/d+Z43WJfj2ttZUGUhehD0cH3DS627YxbFP4eLQrjoq9aFF6AcoT/8cwI5w9oUbjhkWGD6s0+0SdD9p0N4o39pOHD5yIfPEP0+R3eKo9l9s6i82/Bt/faQN+3/Y3b7lwBfJvkYPAzGVCqwz/LKhB3/re2Zzx3gKeGy/sD/pyjY3UEnr8S8DmHr5/sCPglITf1OYe9G1leWz55NQLk1RHysrLG0eh93JSSptmjKPXZTvn4C+CD7b0JdIt0ivBldWoy6xE86xdlgrhQ5pcIflw75A00Bn9VtEPVF1m9Ox7c6MPVGjJvwom158FkojabId89konBr3raudo8ptaJmQeE53qjvHCd8iK95ztuXuFWtIv2dJgemU4Mvaij8RuCbz76/ucC/YnZXFx/Mhwof4L2wf7EZwtpYtt5RcCzbpwbtVc8IpTtQ+3X8PkTe7/In+CGPYRf9/gTHC9ZvTse3LhRMPLntcNJbfPjHp+h9K4+1yur967Lt2N7t/6sZPQ/JxVHK/tZia8/8LUro1PUror6pE+JdtXxvK8+bTF9zBTQtiN6zXZQDxW2tRf9gNnALPBzXfDTJPjPNI7XC49Lb7i87eHRw2hDSHeF6op0l4luqoN/bk5DVut95rlZUMfrBTx/1uOXqriiAevNcWRs48vEn5X9RsZfaq/92eP0XhZ7fXBK9vpA2CvXxRXwwH7L6jlXAH+NeDD49zzz/GWqw0723J8ojdrMCvDUcONt0uC/4GkzVVxTsizk1nV5e+K1y3E642vujE6ozgz+ix6dsd3tZM/9idJIZzeAJ6WzFeLZ4L/k0VkVV8WsCLl1XV6fNwjXOJ1dcZrXUJ0Z/Jc9OkOeYujsJvCkdHaDeDb43/PoTOnAp7ObAv6GkFvX5fV5k3CN0xnHQI1OqM4M/g88Ootzpc9IZ7eAJ6Wzm8Szwf+hR2dKBz6d+a4VUjpDfd4iXON09qrTvIbqzOD/xKOzONdCjXS2Cjwpnd0ing3+Tz06Uzrw6WxVwN8Scuu6vD5XCdc4nXEMw+iE6szg/9yjs1V4P4bObgNPSmerxLPB/5VHZ/YOys2ns9sCflXIrevy+rxNuMbp7KLTvIbqzOD/9hzq7B9OUWco09tUhrzzOsPqmLryMWsG/1Wo6780i+nxMWurgpeuy9sa83kne8a5IMKb3ZmNvAFlMeaCr2f4cE72huCnSfAf0FzwzSwf54J3BB6D/5ig+ybA3Ca6HyO6KnbxehRZDTcSkkuzoI6vE88G/++iPal4v9lb5Hj/por3m7w/4h/oYr2cy9tsmrjNvyHgUTcms57L29t1wqX8NMo8ZH6P8EXz+697/DS+H8Ou0G6U77pDPBv8/wTalenqNOwKY3NsV3egrCHg2a6UHSrd9lze5pYJl4p/oMzZrkyGcy4sBmPwH3rsCv1+DLtCu1ExG/axBv9/gXZlujoNu0K/wHZ1G8oaAp7tStkh6sZk1nN5m+PYlopFo8zZrlScBOE5Hm7w3516bGtkV2g33G6RPreFH5yDfhD9AtuVLwaappCxL+rGZNZzeZsLib+hzEPsCuGL4m+22es07OqkMdNZ4NlnV6ars9YPKrvy9YOhcd2ey9sSxwjL9oPKrkLWIrpnzK7QxxbZ1aVAuzqr/aCyK18/OM6uuB/0xTGn1Q/ePGN25esHDf5OoF29LP3gOLvifhDt6irhuipwrQIM25XJcK4AHo/nR/ifF3alzubhNrEocPv2BGA9GiXr0Qiox1DUo+N5X11hMO6qad6Ta/DbcNX0D2c1zqI9EbbO0XJ5O4gRB7P1S4xHqXWXJsG/TfUyW8Y42GWBh/VatBejQXSvEV21JwL3shlOXFPndT/UvYK/QjwY/Dse3xtHX/tDlhvaJK5BF7WHTwrf62uTuBbIfi10Tdziwij3a248baxPiD8Iqf+venQWZ9/RSGcn3fv1ax6dqXGGT2dV7P3yzadMdr76IY5rgnYC5SG2wftlVAzUZxsG/+vn0DbunaJtoEw5vqhoXxK4mPZcAXxR/R9Offw70tlJx7+f9+hMjS19OgsdW4bscVI6w7bFOlNzliVBm+csh+dQZ791ijpDud+gMuSd91msAH01xuR9t3H2vfRzewJxrHdL8MOy/10aY94G2Sn58b7bVUH3NtUV6a4SXbXWehp7hLCORXuEfv9MxWzW5bdVaP9NoIv1cm5Ub4Qvu4/JZNYj+MTlv5tT/g9lzmNQtY9JtWPex/RHHv93GnaFPqTIrv440K5MV6dhV+iHQ+wK4cvaFcdsVqGM9wKr+ahv7ULtQ70u8LOf/IrHrmLvHVb7UFEOvHfY4P8y0K5MV6dhV761C9WX+9YufP4NZdZzeZsLWcP3zZnVeE2N4Xm89vdTH6/5vyMIWbv4x3PQD6JfYLtSY0qEr3LtIiTG7Fu7UPPtZYGf59tf89jVaXxTdFXIi9vCB4F2Zbo6a/7KN8dPU9nvnkxmPZe3Od77qfpB37dq47574n7Q4P/rjNlViI/9+jnwV+gXQuwK4cvaFfeDaFccv78scPn6wXHxQb4a0OC/MfX4oP+7YZRDUXzsw0C7wnO+0zR7FKU+pftBNSfz9YPjYpgms57L2xzv0Vb9IMo8xK4Qvqgf/PYZs6uQuPN3z0E/iH4hxK4Q/qSxcWVXvB8J43RG07dGjDR9a+RXAJeCZ79m8D8JXCNHXm8kz/+PqdfNreexw4/qfzTi3XjCNAvlx+CzDDwXzn5nJ+Dz/ubu4P7d3fu767v7+8O93VcIf5rwzL4FYG4J5Pb0tx/tvfv48OCpG5MWI1Ti4N5we/Pe9t56f7+/Pdi+W6YSfIizc1U15n7u1kHkqQX1dq5qR/L8ACGk59zxRuCIftvlG0qF/Lw4OFZd/tAQejLZNQWvPVHGjq4p6DQFnWnhCjmwGt+rUPbrobZg9Kd1YLWSqzqkkg9gxnfVYV6sv7IXdJwHXGw7qMcqF71agnfnqveRvjaj6q0u+Sm6HAbxdwrkhWXYNow29xshl03igZVVysz4twOHiy7bMfpNgt+gvq9FstipiE/uh5GWkl/DI78K+bqr5NfwyC/uhQL9Aevns5l+UnofJ3vjA5KxDA/KnqEy1jGW4XhslsoWxXsmj04cebzQj7qFWR083CT4dzKZjZvUoX7TNHsUpT5DNanDw3ybQBfr5Vx+Q0qauB9Rh2mqw3zVxmfzi12X98O8Ia3sOGgpkM7ChHQWBB0fLmwL3LeYTcwVwBu+JsF/GmyON5qj/1si3lGXC1TWEHTVZWVt4Pl3yLdH8qEvDs83njGpSxa430afw/298jncblgGnHhyjbJIef4a+QUncFXpc3ls0KY67mTP/QnTWfNzxy7EODouR3WgOcKznws9pF4daO7zP7zAU9b/LAbSieHnlI9hfx/qY+aoDNsXHqpuPqZoTKzm7GoMlaad7Lc/YWL/rcb+SJ/995fJb8a5dESPifnCk0hxgA11kZElvjxG+Wzl65SvZ5+txpeJ4EH5bJNFWZ/N4wAsU3Ny5euNH9XGuP1hG+N2hG2M5xSIM0072W9/sjRQbTjx0K7SxhOqt3P++EZCvCJ8Q/CvLuvieYvSVVJQb8xDvnpuvC0hrrkJ6fjiHIgLY9lVx9KH67ube7ubg8H2cHAwHKyPi6VXHsvf2n4WxL9/sDsYDNb2+wfj6L+4GOBoVI5jnzTNZ882z2d4w9ck+L+GefjfkO9pCnop3Fc9cEnB70c4RN7s0fG81lEevnGUhzfa7aM8j1a2CGVNorOUPaO8EJfx0ST4f4JxQJoW4B17vyfoLxD9Y3yLPI5FLgr4RQGf6ufvaCEN615lTAdtIUY72RhuDLa2drf2Nvbubw/37k27nQ6frRxu3N/sr6/tDw/W9ndPsuYWKZ52N/Lctx95jDhQMXGMS/xrc5SPZRgnCxnzfgP82394xvC+8RPHElHm3Cer8WPkGPRQXazF46A4F1CHr7sZ/TbxWrVdJUTP+EHdOKGbOBe6jS65UfN6dbFZurFJxaWRP8Ol5q5lx/EcTwidK1sbmNZYFC9TVPOXhORQ5Cd4vcjgPwQ/MT93vG6+2Bi2aZ5nsY1jGeqWfciSwGl2eoFw7mTP/cnSCzvtjpFf0SVU3xLrEQm941xYrL8r4H3xfIyBdamM4/sOZImbu2Ks7eDFQkqWKGuE/75Hlko2Plmqy5Kw3ixLlDO+y3RY7ngB3Fm20x8FrptN54LM/rqKJ2Nf0QS6RW0J4U/altSGR17HQT8+T2VIt0Nl6KO5v8E+BS/UNB+cED2shy/ujLHcMv3AYkZXbbAcN1b9KYS3Uz9Z+QAA",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "lookup_validity"
-      ]
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-3b28ad7111444d0247499926c0239523-mega-honk-true"
     },
     {
       "name": "entrypoint",
@@ -4396,7 +4451,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -4580,7 +4635,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -4695,36 +4750,33 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
-                        "name": "counter",
+                        "name": "note_hash_counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -4732,13 +4784,7 @@
                         }
                       },
                       {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "note_hash_counter",
+                        "name": "counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -4747,15 +4793,15 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
               {
-                "name": "encrypted_logs_hashes",
+                "name": "contract_class_logs_hashes",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 1,
                   "type": {
                     "fields": [
                       {
@@ -4777,50 +4823,27 @@
                         "type": {
                           "kind": "field"
                         }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
                   }
                 }
               },
               {
-                "name": "contract_class_logs_hashes",
+                "name": "start_side_effect_counter",
                 "type": {
-                  "kind": "array",
-                  "length": 1,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
-                  }
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
                 }
               },
               {
@@ -5210,8 +5233,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "H4sIAAAAAAAA/+2dB5gURdeFZyM5g6AoUXKa3rySc0aiBBHYSJCck4AIihEDKiIIGFAJKiiSc5QoWRRRUAwgGMAEin+V9ny2TbOGPXfo88/085TM7oy19773dJ3umpqaEM8fR78bPZ5f8v/xOES1MPPfUNVK2H7n+9f6OMLhdTkcfpfL4Xd5HH6Xz+F316lWx/a74g6vK+Hwu5IOvyvl8LsyDr8r5/C7Cg4MKjr8rrLD/1vV4XXVHH5nOPy/0Q6vi3H4XZzD/5vg8LpEh9/VcPh/azm8rrbD7+o6/L/1HV7XwOF3jRx+19j813r4fq5j/hvtjYuJSYuPSjOijSRvVGJyQqw3JjY5LsFIMGITYlOjEqKj0xJiEuITkxPjvYlGTHSakR6bGJ3u/eOIDv2zL2+mjqgUyThj/nOcUdH23+jYCqgWbolVc7hsPi7r+fNxOcvjGPM1vv8vVv0cp1q8agmhf/7ed4TZGHgzdxjlgX3FhuJqkwjTkNcrya8CsK84IL9bSPhVBPYVD+RXHcjPaWxItIwNt1geV7c8TrCNDTXUzzVVq6VabT+MDZWAfdUA1qYOibYrA/uqCeRXl4RfFWBftYD86gmPDXUsY0Bdy+N6lse1bWNDffVzA9UaqtbID2NDVWBf9YG1aUyi7WrAvhoA+TUh4ecF9tUQyK+p8NjQ2DIGNLE8bmp53Mg2NjRTPzdXrYVqLf0wNhjAvpoBa9OKRNtRwL6aA/ndSsIvGthXCyC/1sJjQyvLGHCr5XFry+OWtrGhjfq5rWrtVGvvh7EhBthXG2BtOpBoOxbYV1sgv9tI+MUB+2oH5NdReGzoYBkDbrM87mh53N42NnRSP3dWrYtqt/thbIgH9tUJWJuuJNpOAPbVGcjvDhJ+icC+ugD5dRMeG7paxoA7LI+7WR7fbhsbuqufe6iWpFqyH8aGW4B9dQfWJoVE29WBffUA8ksl4VcD2FcSkF+a8NiQYhkDUi2P0yyPk21jQ7r6uadqvVTr7YexoSawr3RgbfqQaLsWsK+eQH53kvCrDeyrF5BfX+GxoY9lDLjT8riv5XFv29jQT/3cX7UBqg30w9hQB9hXP2BtBpFouy6wr/5AfoNJ+NUD9jUAyG+I8NgwyDIGDLY8HmJ5PNA2NgxVPw9TbbhqI/wwNtQH9jUUWJuRJNpuAOxrGJDfKBJ+DYF9DQfyGy08Noy0jAGjLI9HWx6PsI0NY9TPY1W7S7VxfhgbGgH7GgOszXgSbTcG9jUWyG+CsLbHWzQ8wfL4LsvjcTZt361+nqjaPapNctB2KLg2ZTw4npNxPA3rOnXdbwkbB/T673thsUdFScZ533+O04iz/8ZJs/eG/v069ftsmp2ifr5ftQdUe9AP4zFynfoU4HjyEMl4jFynfj+Q38Mk/JDr1B8A8ntE2M8esowND1seP2J5/KBtbJiqfn5UtcdUe9wPYwNynfpUYG2eINE2cp36o0B+00j4IdepPwbk96Tw2PCEZQyYZnn8pOXx47ax4Sn189OqTVftGT+MDch16k8BazODRNvIdepPA/k9S8IPuU59OpDfTOGxYYZlDHjW8nim5fEztrFhlvr5OdVmqzbHD2MDcp36LGBt5pJoG7lO/Tkgv+dJ+CHXqc8G8ntBeGyYaxkDnrc8fsHyeI5tbHhR/fySavNUe9kPYwNynfqLwNq8QqJt5Dr1l4D8XiXhh1ynPg/Ib77w2PCKZQx41fJ4vuXxy7axYYH6eaFqi1R7zQ9jA3Kd+gJgbV4n0TZynfpCIL83SPgh16kvAvJbLDw2vG4ZA96wPF5sefyabWxYon5+U7W3VFvqh7EBuU59CbA2bwvX5m1LDd60PH7L8niprTbL1M/LVVuh2kqH2qDfR1sFY2CkSca5+r/Hmer9B7VaZamJ/lyA73ENy+PVtlqtUT+vVW2dauv9cB4h13SvAZ5HG0g8ohawr7VAfhtJ+CHXdK8D8tskPI5vsIwNGy2PN1ker7eNDZvVz1tU26raNj+MDXWAfW0G1mY7ibbrAvvaAuT3Dgm/esC+tgL57RAeG7ZbxoB3LI93WB5vs40NO9XPu1TbrdoeP4wNyDXdO4G12UuibeSa7l1Afu+S8EOu6d4N5LdPeGzYaxkD3rU83md5vMc2NuxXPx9Q7aBqh/wwNiDXdO8H1uawcG0OW2pwwPL4oOXxIVttjqif31PtqGrv++He/APcvXm6ZJzH/nuc/2jP6A8sNVlmeXzE8viYrVYfqp+Pq/aRah+btQq35e901IHw9hpZLH2eCP3j35Pmv5+Y/35q/nvK/Pcz89/PQz1/3aBc/6KELdBQcBFDgMl/KmRMduF6M3cYnwEHrHDPnxvL2w903CeAfEMtcX5h/vBlqC0BtOucAIL/4p/3lfI3fRlfAsH6UxAnhQRx2vzhjLQgTgIFcRooiDOkgvhESBBfmT+clRbEJ0BBfAUUxFnwdWk21XJaOPr6jkqIik2JT0xJiUuKTUlOTktLj0+NS0pIN5Ljkoyo5GgjKikpOjohJsablJaelhwTnRhnxCSkJKiI41O8MYmXbf0ZKtX0VCM1KTYmOd4bF5UalxyrQaRFxyUneuOj46Jjvelx6clJXiMqKiElxkiJj/ImJsZ6E9Nj49V7O5ex9fVeIfi01GQjLSoxOiU6JS3RSE5XSaSph0lJsd7UqJTYGCM9KTFVFUTFpdL1RqelJxsp6UlRKcnR0bHx6VfkGx1jpMbFx6YnqWvMtJS0aMOITkqNjU5Jio5RHKKTjcTkuLTE+Lgob0xcvPpdjMIXFZMSoyinpkXHiucbozhHq2Ip6XmVBlNTEqLSEpJiY5MSY6NSY1LTo7xRsXHpaV6lvdTEmET1a1WTJK833ZuUnG5cGV9SgiYTp97tUv9Jj01NULKOSUyNSUiP9sbEpHqVPLzJiQlpqfFGfFJicmx0VFJ6XLQ3xYiN9sYnGsF8M59vVrMv/fgLy73Jl5bHpy2Pz1gef2V5fNZ8DIwPnq/u75yK82vVvjHvr7J4/GNun4fidaqPb0MFA9ado/v9DmiSUnl/Z7lSAPWb4T1hZjmcx4kr2mky47zlRD9leXwug8mMC+rn71X7QbUfQ+U/DD8ZqKufcDz/8mH4n8w5kXAzf38MPB8KDDzWeZefVf8XVbuk2i+q/ap1oNpvoX8kHqJaqGphqoWrFqFapGpZVMuqWjbVsquWQ7WcquVSLbdqeVTLq1o+1fKrVkC1gqoVUu061QqrVkS161W7QbWiqt2o2k2qFVOtuGolVCupWinVSqt2s2plVCurWjnVyqtWQbWKqlVSrbJqVVSrqlo11byqGapFqRatWoxqsarFqRavWkKYWcysFkFLFvNnoUkqDzJO46+3X4nmbdYtvrPA969+4gfb7/SLstqCQt+m/QwYKdLS9eE1dA6Z7et/X/UWJlNc9EiLzLn6X/pSr02KiolLi/XGpSWo6+DEeH0jl5KUnp4a741JSfYmJ8fEeaON6PRkdaeXHJWo/mxiWmyK8Xtc/rycqx6GH1X1USNMMGDdObrfmmHuvpzTedcM+xMwqF/HWBEDQM0wfL+1wGL1Dda6Xz0X5E8HvEjogLVN/dWxO2BtBwes4wcHvAh0wNrAAaAOiQMic65L6oB1hRywXphgwPUEHLC+yx1Q512fxAHrmLGi+20g5IANroEDXiJ0wIam/hrZHbChgwM28oMDXgI6YEPgANCIxAGROTcmdcDGQg7YJEww4CYCDtjU5Q6o825K4oCNzFjR/TYTcsBm18ABfyF0wOam/lrYHbC5gwO28IMD/gJ0wObAAaAFiQMic25J6oAthRywVZhgwK0EHPBWlzugzvtWEgdsYcaK7re1kAO2vgYO+CuhA7Yx9dfW7oBtHBywrR8c8FegA7YBDgBtSRwQmXM7UgdsJ+SA7cMEA24v4IAdXO6AOu8OJA7Y1owV3e9tQg542zVwwMuEDtjR1F8nuwN2dHDATn5wwMtAB+wIHAA6kTggMufOpA7YWcgBu4QJBtxFwAFvd7kD6rxvJ3HATmas6H67Cjlg12vggL8ROuAdpv662R3wDgcH7OYHB/wN6IB3AAeAbiQOiMy5O6kDdhdywB5hggH3EHDAJJc7oM47icQBu5mxovtNFnLA5GvggJ4wPgdMMfWXanfAFAcHTPWDA3rCcA6YAhwAUkkcEJlzGqkDpgk5YHqYYMDpAg7Y0+UOqPPuSeKAqWas6H57CTlgr2vggCGEDtjb1F8fuwP2dnDAPn5wwBCgA/YGDgB9SBwQmfOdpA54p5AD9g0TDLivgAP2c7kD6rz7kThgHzNWdL/9hRyw/zVwwFBCBxxg6m+g3QEHODjgQD84YCjQAQcAB4CBJA6IzHkQqQMOEnLAwWGCAQ8WcMAhLndAnfcQEgccaMaK7neokAMOvQYOGEbogMNM/Q23O+AwBwcc7gcHDAM64DDgADCcxAGROY8gdcARQg44Mkww4JECDjjK5Q6o8x5F4oDDzVjR/Y4WcsDR18ABwwkdcIypv7F2Bxzj4IBj/eCA4UAHHAMcAMaSOCAy57tIHfAuIQccFyYY8DgBBxzvcgfUeY8nccCxZqzoficIOeCEa+CAEYQOeLepv4l2B7zbwQEn+sEBI4AOeDdwAJhI4oDInO8hdcB7hBxwUphgwJMEHHCyyx1Q5z2ZxAEnmrGi+71XyAHvvQYOGEnogPeZ+ptid8D7HBxwih8cMBLogPcBB4ApJA6IzPl+Uge8X8gBHwgTDPgBAQd80OUOqPN+kMQBp5ixovt9SMgBH7oGDpiF0AEfNvX3iN0BH3ZwwEf84IBZgA74MHAAeITEAZE5TyV1wKlCDvhomGDAjwo44GMud0Cd92MkDviIGSu638eFHPDxa+CAWQkd8AlTf9PsDviEgwNO84MDZgU64BPAAWAaiQMic36S1AGfFHLAp8IEA35KwAGfdrkD6ryfJnHAaWas6H6nCzng9GvggNkIHfAZU38z7A74jIMDzvCDA2YDOuAzwAFgBokDInN+ltQBnxVywJlhggHPFHDAWS53QJ33LBIHnGHGiu73OSEHfO4aOGB2Qgecbepvjt0BZzs44Bw/OGB2oAPOBg4Ac0gcEJnzXFIHnCvkgM+HCQb8vIADvuByB9R5v0DigHPMWNH9vijkgC9eAwfMQeiAL5n6m2d3wJccHHCeHxwwB9ABXwIOAPNIHBCZ88ukDviykAO+EiYY8CsCDviqyx1Q5/0qiQPOM2NF9ztfyAHnXwMHzEnogAtM/S20O+ACBwdc6AcHzAl0wAXAAWAhiQMic15E6oCLhBzwtTDBgF8TcMDXXe6AOu/XSRxwoRkrut83hBzwjWvggLkIHXCxqb8ldgdc7OCAS/zggLmADrgYOAAsIXFAZM5vkjrgm0IO+FaYYMBvCTjgUpc7oM57KYkDLjFjRff7tpADvn0NHDA3oQMuM/W33O6AyxwccLkfHDA30AGXAQeA5SQOiMx5BakDrhBywJVhggGvFHDAVS53QJ33KhIHXG7Giu53tZADrr4GDpiH0AHXmPpba3fANQ4OuNYPDpgH6IBrgAPAWhIHROa8jtQB1wk54PowwYDXCzjgBpc7oM57A4kDrjVjRfe7UcgBN14DB8xL6ICbTP1ttjvgJgcH3OwHB8wLdMBNwAFgM4kDInPeQuqAW4QccGuYYMBbBRxwm8sdUOe9jcQBN5uxovvdLuSA26+BA+YjdMB3TP3tsDvgOw4OuMMPDpgP6IDvAAeAHSQOiMx5J6kD7hRywF1hggHvEnDA3S53QJ33bhIH3GHGiu53j5AD7rkGDpif0AH3mvp71+6Aex0c8F0/OGB+oAPuBQ4A75I4IDLnfaQOuE/IAfeHCQa8X8ABD7jcAXXeB0gc8F0zVnS/B4Uc8OA1cMAChA54yNTfYbsDHnJwwMN+cMACQAc8BBwADpM4IDLnI6QOeETIAd8LEwz4PQEHPOpyB9R5HyVxwMNmrOh+3xdywPevgQMWJHTAD0z9HbM74AcODnjMDw5YEOiAHwAHgGMkDojM+UNSB/xQyAGPhwkGfFzAAT9yuQPqvD8iccBjZqzofj8WcsCPr4EDFiJ0wBOm/k7aHfCEgwOe9IMDFgI64AngAHCSxAGROX9C6oCfCDngp2GCAX8q4ICnXO6AOu9TJA540owV3e9nQg742TVwwOsIHfBzU39f2B3wcwcH/MIPDngd0AE/Bw4AX5A4IDLnL0kd8EshBzwdJhjwaQEHPONyB9R5nyFxwC/MWNH9fiXkgF9dAwcsTOiAZ039nbM74FkHBzznBwcsDHTAs8AB4ByJAyJz/prUAb8WcsBvwgQD/kbAAb91uQPqvL8lccBzZqzofr8TcsDvroEDFiF0wPOm/i7YHfC8gwNe8IMDFgE64HngAHCBxAGROX9P6oDfCzngD2GCAf8g4IA/utwBdd4/kjjgBTNWdL8/CTngT9fAAa8ndMCfTf1dtDvgzw4OeNEPDng90AF/Bg4AF0kcEJnzJVIHvCTkgL+ECQb8i4AD/upyB9R5/0rigBfNWNH9XhZywMvXwAFvIHTA33z6C/f81e1+c3BA/SJpB7wB6IC/IQeAcA4HROYcEs7pgCHhMg4YGi4YsO4c3W9YuLsdUOcdFv4nYFC/Ig7oMWNF9xseLuOAul9/O2BRQgeMMPUXaXdA/YTdASP94IBFgQ4YARwAIkkcEJlzFlIHzCLkgFnDBQPOKuCA2VzugDrvbCQOGGnGiu43u5ADZr8GDngjoQPmMPWX0+6AORwcMKcfHPBGoAPmAA4AOUkcEJlzLlIHzCXkgLnDBQPOLeCAeVzugDrvPCQOmNOMFd1vXiEHzHsNHPAmQgfMZ+ovv90B8zk4YH4/OOBNQAfMBxwA8pM4IDLnAqQOWEDIAQuGCwZcUMABC7ncAXXehUgcML8ZK7rf64Qc8Lpr4IDFCB2wsKm/InYHLOzggEX84IDFgA5YGDgAFCFxQGTO15M64PVCDnhDuGDANwg4YFGXO6DOuyiJAxYxY0X3e6OQA954DRywOKED3mTqr5jdAW9ycMBifnDA4kAHvAk4ABQjcUBkzsVJHbC4kAOWCBcMuISAA5Z0uQPqvEuSOGAxM1Z0v6WEHLDUNXDAEoQOWNrU3812Byzt4IA3+8EBSwAdsDRwALiZxAGROZchdcAyQg5YNlww4LICDljO5Q6o8y5H4oA3m7Gi+y0v5IDlr4EDliR0wAqm/iraHbCCgwNW9IMDlgQ6YAXgAFCRxAGROVcidcBKQg5YOVww4MoCDljF5Q6o865C4oAVzVjR/VYVcsCq18ABSxE6YDVTf167A1ZzcECvHxywFNABqwEHAC+JAyJzNkgd0BBywKhwwYCjBBww2uUOqPOOJnFArxkrut8YIQeMuQYOWJrQAWNN/cXZHTDWwQHj/OCApYEOGAscAOJIHBCZczypA8YLOWBCuGDACQIOmOhyB9R5J5I4YJwZK7rfW4Qc8JZr4IA3EzpgdVN/NewOWN3BAWv4wQFvBjpgdeAAUIPEAZE51yR1wJpCDlgrXDDgWgIOWNvlDqjzrk3igDXMWNH91hFywDrXwAHLEDpgXVN/9ewOWNfBAev5wQHLAB2wLnAAqEfigMic65M6YH0hB2wQLhhwAwEHbOhyB9R5NyRxwHpmrOh+Gwk5YKNr4IBlCR2wsam/JnYHbOzggE384IBlgQ7YGDgANCFxQGTOTUkdsKmQAzYLFwy4mYADNne5A+q8m5M4YBMzVnS/LYQcsMU1cMByhA7Y0tRfK7sDtnRwwFZ+cMByQAdsCRwAWpE4IDLnW0kd8FYhB2wdLhhwawEHbONyB9R5tyFxwFZmrOh+2wo5YNtr4IDlCR2wnam/9nYHbOfggO394IDlgQ7YDjgAtCdxQGTOHUgdsIOQA94WLhjwbQIO2NHlDqjz7kjigO3NWNH9dhJywE7XwAErEDpgZ1N/XewO2NnBAbv4wQErAB2wM3AA6ELigMicbyd1wNuFHLBruGDAXQUc8A6XO6DO+w4SB+xixorut5uQA3a7Bg5YkdABu5v662F3wO4ODtjDDw5YEeiA3YEDQA8SB0TmnETqgElCDpgcLhhwsoADprjcAXXeKSQO2MOMFd1vqpADpl4DB6xE6IBppv7S7Q6Y5uCA6X5wwEpAB0wDDgDpJA6IzLknqQP2FHLAXuGCAfcScMDeLndAnXdvEgdMN2NF99tHyAH7XAMHrEzogHea+utrd8A7HRywrx8csDLQAe8EDgB9SRwQmXM/UgfsJ+SA/cMFA+4v4IADXO6AOu8BJA7Y14wV3e9AIQcceA0csAqhAw4y9TfY7oCDHBxwsB8csArQAQcBB4DBJA6IzHkIqQMOEXLAoeGCAQ8VcMBhLndAnfcwEgccbMaK7ne4kAMOvwYOWJXQAUeY+htpd8ARDg440g8OWBXogCOAA8BIEgdE5jyK1AFHCTng6HDBgEcLOOAYlzugznsMiQOONGNF9ztWyAHHXgMHrEbogHeZ+htnd8C7HBxwnB8csBrQAe8CDgDjSBwQmfN4UgccL+SAE8IFA54g4IB3u9wBdd53kzjgODNWdL8ThRxw4jVwQC+hA95j6m+S3QHvcXDASX5wQC/QAe8BDgCTSBwQmfNkUgecLOSA94YLBnyvgAPe53IH1HnfR+KAk8xY0f1OEXLAKdfAAQ1CB7zf1N8Ddge838EBH/CDAxpAB7wfOAA8QOKAyJwfJHXAB4Uc8KFwwYAfEnDAh13ugDrvh0kc8AEzVnS/jwg54CPXwAGjCB1wqqm/R+0OONXBAR/1gwNGAR1wKnAAeJTEAZE5P0bqgI8JOeDj4YIBPy7ggE+43AF13k+QOOCjZqzofqcJOeC0a+CA0YQO+KSpv6fsDvikgwM+5QcHjAY64JPAAeApEgdE5vw0qQM+LeSA08MFA54u4IDPuNwBdd7PkDjgU2as6H5nCDngjGvggDGEDvisqb+Zdgd81sEBZ/rBAWOADvgscACYSeKAyJxnkTrgLCEHfC5cMODnBBxwtssdUOc9m8QBZ5qxovudI+SAc66BA8YSOuBcU3/P2x1wroMDPu8HB4wFOuBc4ADwPIkDInN+gdQBXxBywBfDBQN+UcABX3K5A+q8XyJxwOfNWNH9zhNywHnXwAHjCB3wZVN/r9gd8GUHB3zFDw4YB3TAl4EDwCskDojM+VVSB3xVyAHnhwsGPF/AARe43AF13gtIHPAVM1Z0vwuFHHDhNXDAeEIHXGTq7zW7Ay5ycMDX/OCA8UAHXAQcAF4jcUBkzq+TOuDrQg74RrhgwG8IOOBilzugznsxiQO+ZsaK7neJkAMuuQYOmEDogG+a+nvL7oBvOjjgW35wwASgA74JHADeInFAZM5LSR1wqZADvh0uGPDbAg64zOUOqPNeRuKAb5mxovtdLuSAyy0OmM3z50BtPdD1/DCUwAG9UaLuGmJhW8J8vEIVYaVqq1Rbrdoa1daqtk619aptUG2japtU26zaFtW2qrZNte2qvaPaDtV2qrZLtd2q7VFtr2rvqrZPtf2qHVDtoGqHVDus2hHV3rM7+wrTxa2/W+nwu1UOv1vt8Ls1Dr9b6/C7dQ6/W+/wuw0Ov9vo8LtNDr/b7PC7LQ6/2+rwu20Ov9vu8Lt3HH63w+F3Ox1+t8vhd7sdfrfH4Xd7HX73rsPv9jn8br/D7w44/O6gw+8OOfzusMPvjjj87j2HK8aS5r91zH+9mTv+MuhkdjBeEY67+lwJ6kvnuArS1x+8Vme+ryiTl7Ems33F/I+9sTZzfXktdTTWZaavqL9owlj/3/vy2vRlbPiPfcWlX6FVY+N/6yvBQffGpv/SV4LjOWRs/vd9xV/lfDS2/Nu+4q96bhtb/11fURmME8a2f9NXfIZjjrH9n/eV8jfjl/HOP+0r/m/HQmPHP+vL+w/GVWPnP+nL+4/GaGPX3/cV+w/He2P33/UV84+9w9iTYV8x6f/Ch4y9GfUV/688zXj36n0l/Et/NPZdpa/E9H/ttcZ+5768/8G3jQNOfXn/0zWAcfDKvoz/eD1hHLL3lfqfr02Mw3/tKzoT1znGEUtfUemZumYy3vPTzFhmr+3eC8f1dRSWc7TXnzNjR4G1ssb7frhgwO8LzIx94PKZMZ33B+F/Agb16/Xn+yG4gSHVb++HHDOZf2ifNTlmitD6uw/98H4IYtTy3ZEeA4r+Q3BxJU7wY+H46dpjJG53BFjr47Cc42L86XbHhdzuo3DBgD8ScLuPXe52Ou+Pyd3uCExsiSkO4Yq43QmT+Um7251wcLuTfnC7I0C3OwEU/Umh4qJHfWTOn+BGT8PjwTvxB+aggV5Bgbw1+BR8tYAetHSNPxW4SnJ73h8I5X2K5OrwMFDjn8Fyjknz59XhZ8BaWeP9PFww4M8Frg6/cPnVoc77C4GrQ6dYEaZ0yuWm9CXJIIXU5WngxYw/7yoOw+JOjnIIV+Su4ox5rn5lv6s443BX8ZUf7ioQbue7qzgDFOVXQsVFn4jInM8K31V4M3cYenA8LXBleM7lV8S6LucI8w4Ew/7a5drRNf5aQDvfkFyoHALW+ltYzvFR/ryb+hZYK2u834ULBvydwN3UeZffTem8z5PdTaH7rZPP3Xnri5BvBPKum09mQA0HaxRpnheAF5xA3RhStUCbG3I8+570LvwQLO6ENIdwRe7CfzBPyh/td+E/ONyF/+iHu3DEVZLvLvwHoCh/FCou+kRE5vyTy+/C9aD9vYAB/uzyOyldl58J8vYdbjb+iwFi/GgNaq1cFNDgJZK7+YNADf4CyznNrzso/AKslTXeX8MFA/5V4G7+ssvv5nXel0nu5rWpXxIYWBoQ3tV6M3eIGVJma9FQqBZhYM38BqwFUH9GQ5JZAei4GME5K3AQpiEj3SFckVmBkAhTDxGev84A6CfsswL6RdKzAoirLd+sQEgETpShETLFRZ+IyJzDgCfi72IDa0UP2p4I/AVEeITshZM3c4eh6xJOkLfvQJt1RERgmDVaN7q+EQK6iYzguEg5ALxIyQLLOdqvd/JZgLWyxps1QjDgrBH4frMBjVIq72wRfwIG9StyJ6+NOFJgYGnipzv5zMaZ/f+/IRlNSO5Eked1DtI70QOwO9EUv92J5jTHulz2O9GcDneiufxwJ3oAeCeaEyjKXBEyxUWfiMicc7v8TlQbQA4BA8zj8jtRXZc8BHn7DrTx5w0a/786JDSotZJXQIP5SO5q9wPvavPDck7y6z5m+YXuagtECAZcQOCutqDL72p13gVJ7mq1qetBAH1h2UBocM5svs1J3qstFOFOo2xOcoeMHCOuI71D3g+7Q47z216Ehc1xs4j9Drmwwx1yET/cIe8H3iEXBoqySIRMcdEnIjLn611+h6wH7esErtJvcPkdsq7LDQR5+w60WRcNELNG60bXt6iAbm4kuavdB7yrvQmWc1SiP+9qbxK6qy0WIRhwMYG72uIuv6vVeRcnuavVRnyjwMDSiuS92hL//w3JaEVyJ4o8r0uS3onug92JpsY7hCtyJ1rKHOtK2+9ESznciZb2w53oPuCdaCmgKEtHyBQXfSIic77Z5Xei2gBKChhgGZffieq6lCHI23egjb9s0Pj/1SGhQa2VsgIaLEdyV/su8K62PCzn5AR/3tWWF7qrrRAhGHAFgbvaii6/q9V5VyS5q9WmXk5gYGlN8lnihu40EaM18P3pNiTvT1eKcOfFQRuSWQHkuFiZdFbgXdyXKCQ4hCsyK1DF9Iqq9lmBKg6zAlX9MCvwLnBWoApQlFUjZIqLPhGROVdz+ayAHrQrC1xAeF0+K6Dr4iXI23egzdoIELNG60bX1xDQTRTJnfxe4J18NCznWL+uuo4WupOPiRAMOEbgTj7W5XfyOu9Ykjt5bcRRAquu3XpX24HkffO4AJg+70Byh4wcb+JJ75D34r4syW8ruBPMMTjRfoec4HCHnOiHO+S9wDvkBKAoEyNkios+EZE53+LyO2RtAPECV/zVXX6HrOtSnSBv34E2/hpB4/9Xh4QGtVZqCGiwJsnd9h7g3XYt3OxrrD/vtmsJ3W3XjhAMuLbA3XYdl99t/14okrttbeo1BQaWTgH4vjnSkDoBZxg6k7xvXjfClYZudCaZFUCOi/VIZwX24GYFkh3CFZkVqG96RQP7rEB9h1mBBn6YFdgDnBWoDxRlgwiZ4qJPRGTODV0+K6AH7XoCFxCNXD4roOvSiCBv34E268YBYtZo3ej6NhbQTROSO/ndwDv5pjg/iPPnnXxToTv5ZhGCATcTuJNv7vI7eZ13c5I7eW3ETQQGlq4BeCcPnL0wugLv5O8gWSvQwqWL6pAXGneQzAogx9iWpLMCu3Gr6ZMcwhWZFWhl+s6t9lmBVg6zArf6YVZgN3BWoBVQlLdGyBQXfSIic27t8lkBbQAtBS5G2rh8VkDXpQ1B3r4Dbfxtg8b/rw4JDWqttBXQYDuSGYZdwBmG9rCcE/z6LV/thWYYOkQIBtxBYIbhNpfPMOi8byOZYdCm3k5gZb5b77aTgmsYMtVXB2AtkknWMHQEXgAB9Wckk8xWIMfrTqSzFbtgsxXxfvv2ts6mh3Wxz1Z0dpit6OKH2YpdwNmKzkBRdomQKS76RETmfLvLZyv0oN1J4q0Tl89W6Lp0Jcjbd6DN+o4AMWu0bnR97xDQTTeSGYadwBmG7qQzDN2FZhh6RAgG3ENghiHJ5TMMOu8kkhkGbcTdBAaW9OCdfKb6SgfeyfckWcOQ7NIFjsgLjZ4kswLIMTaFdFZgJ+GsQKrpO2n2WYFUh1mBND/MCuwEzgqkAkWZRjIrgMw53eWzAtoAUgQuRnq6fFZA16UnQd6+A238vYLG/68OCQ1qrfQS0GBvkhmGHcAZhj6wnGP9+j0BfYRmGO6MEAz4ToEZhr4un2HQefclmWHQpt5bYGDpE4AzDMBZFaMPcIbhTpJauHWBYxKwFn1J1m30A170AfVn9CWZoUF6VH/SGZodsBmaJL99Z8MA07cH2mdoBjjM0Az0wwzNDuAMzQCgKAdGyBQXfSIicx7k8hkaPWj3F7iYG+zyGRpdl8EEefsOtFkPCRCzRutG13eIgG6GksyqvAOcVRmGm1VJ9eesyjChWZXhEYIBDxeYVRnh8lkVnfcIklkVbcRDBT4Z4tYZhkEkaxhG/v9f4GgMIrlDRo43o0jvkN/B3SFHO4Qrcoc82hyDx9jvkEc73CGP8cMd8jvAO+TRQFGOiZApLvpEROY81uV3yNoARglc8d/l8jtkXZe7CPL2HWjjHxc0/n91SGhQa2WcgAbHk9xtbwfebU+A5Rzl1zUME4Tutu+OEAz4boG77Ykuv9vWeU8kudvWpj5eYhov+CmJTPU1FDjDMIykFm5d4DgIWIvhJGsY7gFe9AH1ZwwnmaFBetQk0hma7bAZmlS/rWGYbPr2vfYZmskOMzT3+mGGZjtwhmYyUJT3RsgUF30iInO+z+UzNHrQniRwMTfF5TM0ui5TCPL2HWizvj9AzBqtG13f+wV08wDJrMo24KzKg7Cco6P9OavyoNCsykMRggE/JDCr8rDLZ1V03g+TzKpoI35AYGAZHYCzKsCZJGM08E5+DMm6jUeAFwd93fmWizGGZFYAOcZOJZ0V2AabFUhJdQhXZFbgUdN3HrPPCjzqMCvwmB9mBbYBZwUeBYrysQiZ4qJPRGTOj7t8VkAbwFSBi5EnXD4roOvyBEHevgNt/NOCxv+vDgkNaq1ME9DgkyQzDFuBMwxPwXJO8+u6jaeEZhiejhAM+GmBGYbpLp9h0HlPJ5lh0Kb+pMCnJNx6tz2eZOYjyaVGOR5YiwkkaxieAV4AIRebTiCZrUCO1zNIZyu2wmYrDL+tYXjW9LCZ9tmKZx1mK2b6YbZiK3C24lmgKGdGyBQXfSIic57l8tkKPWjPELhjes7lsxW6Ls8R5O070GY9O0DMGq0bXd/ZArqZQzLDsAU4wzAXlnOMX2cY5grNMDwfIRjw8wIzDC+4fIZB5/0CyQyDNuI5AgPLpOAnQzLV1yTgnfxkkjUMLwIvDoYLzap4M3cYk0lmBZBj7EukswJbYLMCyX6bFZhn+s7L9lmBeQ6zAi/7YVZgC3BWYB5QlC9HyBQXfSIic37F5bMC2gBeErgYedXlswK6Lq8S5O070MY/P2j8/+qQ0KDWynwBDS4gmWHYDJxhWAjLOT7RnzMMC4VmGBZFCAa8SGCG4TWXzzDovF8jmWHQpr5A4mN7QndSkeBaNSRYK+DN3GEAZ3uMKcCZjwdI1jC87tJFnA+QzFYgx+s3SGcrNsNmKxLiHcIVma1YbHrYEvtsxWKH2Yolfpit2AycrVgMFOWSCJniok9EZM5vuny2Qg/abwhc2Lzl8tkKXZe3CPL2HWizXhogZo3Wja7vUgHdvE0yw7AJOMOwDDd77dcZhmVCMwzLIwQDXi4ww7DC5TMMOu8VJDMM2ojfFviUhFvvaqeSvJ+/8v//Yj9jKskdMnK8WUV6h7wJdocc47c75NXmGLzGfoe82uEOeY0f7pA3Ae+QVwNFuSZCprjoExGZ81qX3yFrA1glcMW/zuV3yLou6wjy9h1o418fNP5/dUhoUGtlvYAGN5DcbW8E3m1vxL2f7/Xn3fZGobvtTRGCAW8SuNve7PK7bZ33ZpK7bW3qGwQGlscD8P385i59Px9obsbjwJmPaSTv529x6YLGaSSzFcjxeivpbMVG2GxFotchXJHZim2mh223z1Zsc5it2O6H2YqNwNmKbUBRbo+QKS76RETm/I7LZyv0oL1V4MJmh8tnK3RddhDk7TvQZr0zQMwarRtd350CutlFMsOwATjDsBvnB4Y/Zxh2C80w7IkQDHiPwAzDXpfPMOi895LMMGgj3iUwsEwPwD0JgLMqxnTgnfwzJLVw6ycupgJrMYNkPcm7Ll14CdSyMYNkhgbpd/tIZ2g2wGZo4tIdwhWZodlvXgMcsM/Q7HeYoTnghxmaDcAZmv1AUR6IkCku+kRE5nzQ5TM02gD2CVwYHnL5DI2uyyGCvH0H2vgPB43/Xx0SGtRaOSygwSMksz3rgbM97+HWKvr1WzTfE5rtORohGPBRgdme910+26Pzfp9ktkeb+hGBT2+4deZjNsnMR7LQbIU3c4cxG1iLOSTrST4AXgAhF8HOIZmtQI7Xx0hnK9bjdrNMdQhXZLbiQ9PDjttnKz50mK047ofZivXA2YoPgaI8HiFTXPSJiMz5I5fPVuhB+5jAHdPHLp+t0HX5mCBv34E26xMBYtZo3ej6nhDQzUmSGYZ1wBmGT2A5p/l1PcknQjMMn0YIBvypwAzDKZfPMOi8T5HMMGgjPikwsLwY/I6LTPX1IvBO/iWSWrj1UzrIWZV5JOtJPnPpwl+glo15JDM0SL/7nHSGZh3uW0j9tp7kC/Ma4Ev7DM0XDjM0X/phhmYdcIbmC6Aov4yQKS76RETmfNrlMzTaAD4XuDA84/IZGl2XMwR5+w608X8VNP5/dUhoUGvlKwENniWZ7VkLnO05B8s5Pdafsz3nhGZ7vo4QDPhrgdmeb1w+26Pz/oZktkeb+lmBgWV+AO5P0ldohsGbucMAzrwZ84EzHwtJ1pN8C7wAAi5cNRaSzFYgx+vvSGcr1sJmK7zJDuGKzFacNz3sgn224rzDbMUFP8xWrAXOVpwHivJChExx0SciMufvXT5boQft7wQubH5w+WyFrssPBHn7DrRZ/xggZo3Wja7vjwK6+YlkhmENcIbhZ9z+JH79xMrPQjMMFyMEA74oMMNwyeUzDDrvSyQzDNqIfxL4xIpb72oXk6ytmOrS2YrFwFosIVlb8QvwosWtW8AvIZmtQI79v5LOVqzB7dXht0+/XDb98Df7bMVlh9mK3/wwW7EGOFtxGSjK3yJkios+EZE56/cNUHX1ePAnnDaAXwXuvkIisYMuOm9dFx2j2/P2HWjjD40MGv+/OSQ0qLUSKqDBsEiOC57VwJmPcFjO6X797pdwYK2s8UZECgYcEYnvNzLS3TMfOu/IyD8Bg/oVmfnQph4mMLC8Hfzul0z1NVxotsKbucN4GzjzsZxkbUUW4AUQcBGnsZxktgI5XmcF1sKfsxWrcZ8E8dt3v2QzB9vskZ6/zkxki7xytkK/SHq2YjVwtiIbUJTZI2WKiz4RkTnncPlshR60swpc2OR0+WyFrktOgrx9B9qscwWIWaN1o+ubS0A3uYG68efd9ircYsi/3G3niRQMOI/A3XZel99t67zzktxta1PKLXCSrQ7Au+3ZBHfI3swdxmrg3fZaknUG+YAGjvy0C3Kh5VqSO3fk2J9f+IYBobv8Aj7iz4uWlUIXLQUiBQMuIHDRUtDlFy0674JCFy2+Az0wFwoOzP/qsNYCPTAj9X2dywdmrbvrhM8VdH1WAN+vLgye8vaXGQHj/osZFYkUDLiIgBld73Iz0nlfT2ZGNwTN6F8d1lqgBzukvou6/G0FrbuiAjM4N7r8bQVtaDcK5H2Ty/PWOd8kkHcxsDn63oYt5vA2LJoJuma+A+0RxYMe8a8OqfOnuMD5U8Ll44b2CR1jBDjvZOCM8AShT7Eh1w666Z0RrRHfUpgT6iLqsvn4pOXxLWF/jL/6cR3L40aWxy0sj9taHneyPO5meZxqedzH8nig5fFwy+OxlscTLY+nWB4/Ynk8zfJ4huXxHMvjeZbHCy2Pl1geL7c8Xmt5vNnyeIfl8buWx4ctj49ZHp+0PP7C8vic5fEFy+OLlsfaUHyPIy2Pc1oe57c8LmJ5XMzy+GbL44qWx17L4zjL4xqWx/Usj5tYHreyPG5vedzF8riH5XG65XFfy+PBlscjLY/HWR5Psjx+wPL4UcvjpyyPZ1oeP295/Irl8WuWx2+Zj0t4/jj0796zPH/E8viw5fEhy+ODlscHLI/3Wx7vszx+1/J4r+XxHsvj3ZbHuyyPd1oe77A8fsfyeLvl8TbL462Wx1ssjzdbHm+yPN5oebzB8ni95fE6y+O1lsdrLI9XWx6vsjxeaXm8wnxc0nIv76uHPuqY/3ozdxglgfd7/pyQqunBeoHvKBUpGHApgQmp0i6fkNJ5l/bzjK83c4fxUyiO6c0un5GvZdYHzbAWMMYyLr9B0DUuI3BjVFZoYkH3W8Lzx026/p1lZ5f/HW4esCXjrEESZ3WSOK1jqTeTh1N8mT3Hanv+OAfQ418YsK/aHpmLnXKWMQteeOSgrQcq3YID1Z9xBgcqbJzBgcpdA1WopdblzRuICnrAkriDquXBv5WKvAIuDbyLsF4Jlo/8c6rHd6AFVh54h1rR5W8p++6m0J+EktJSZvuq5PJ6aL1UErgzqyx0Z1Y58q9Tr0gW+m/4TATJIsyDNTlUX1Ui3W3oV6uHN3OHmKFnNt+qJPsTIcfHauDxEe3NvpkrVL66r4oC/ge8ODcqAvP1unyM0f2VEZjdDQHGaLicYU0hhjWBMUa5nGENIYY1gDFGgxmifcl3vYBip+tRJTJwrj9iXH6OVBc6R6oDY4x1OUPNr4IAwwrAa4Y4lzPU11oSOkS+qx5PoMPyke6eS0tw+bvqvmtXdG0SXZ53TaG8b3F53jrnqgJ5VyfIu5xA3jVcnrfPZ+D3a+A3nv21pLEerq+/vMtfK1Iw4FoCSxpru3xJo867duSfgEH9isSqJyC9Lr+Yq+PyJZL1zXqjGdYHxljX5YO9rnFdgcG+ntAbcfWuwRJJpAFIxlmXJM46Ho6xOdBWMjXwuH8lUwOPzMVYfckll3XBV772DdUlToAywAup9D8OiU3VDd8DK48GZuwNfZ8k9blHA7PK1t81jJRb2qEhVouEveUQZZ6pRgPglXjDSGyB0aOSPnkacFzVx/nqjWbQyOVXkbpGjQTybix0FdlY8JzX9U8UYNHE5RrQed8ikHdTl+adGhsTYyR7U6XO+WYE9a4ukHdzgrxrCOTdgiDvmgJ5txRafoiOsxUwTu1DJVXrYfanx3Y9zulzXutfa0FzaRVsfmlX04w3c4fYddGtQC2Gmlq0H6j+pdgiGUjF2BodI3pqRidsnZ1A3KzppNFxtgbG2Ibn5DEC+eRpg45RanQPFegXJfa2QIjWO2jdbwmhwjNwbRd0YKMdwSDS3u0OrN9cRDtwe4GTpz0wxg5BB6Y4eToEqANHIU/I24Qc+DY+B4Zy7Rh0YKMjwSDSSXoQQTimDhL1eSvfGwPAd/3/AjGz+XYOui/FidM5QN03GukSXYTctwuf+0K53h50X+N2gkGkq9vdV59QvoWHyMSlFh1mNt87wAUJBddDDxJA0fw+mN0hMB/RFTiYdQteEVEMZt0C9IooBunc3YWuiLrzXRFBufYIXhEZPQgGkSS3vyOgRVkf/I5AkoADJwFjTA46MMXJkxygDhyLdIoUIQdO4XNgKNfUoAMbqQSDSJrbBxGGD+enE8wjAAv9+wCULlCTNOAA1DN4FUMxAPV0+wAk9ZmiXpFYAUlcZfQSyLu30BVX78g/d6Pw1/fg1PPgTzCRWpLEWYckzvRIjjjvAJug7+hjfk7nzkiB75rR2wjpbX/QV0HIrYRqAwdv6yDWxzKI/d3OEoj9N52MzZu5w0Ds529uYpDicTgy2bfjLhV9TUH3i/T8dUeKvpFX7lLRL4N7e1RR0G/BVsv8pfX/drzoC7xM7yckFvTggcy5v8uv/Hx7uaG/oEJqAM5sXwNcXg+tlwECV+IDwFcxqPjS/jifE6+2Y483c0dCNaB2Bgoz9GbuMHSNBwpoZ5DQXdwgwXlzXXdDgMVgl2tA5x0lkPcQgryjBfIeSpB3jEDewwjyjhXIezhB3nECeY8gyDteIO+RBHknCOQ9Cpi39vNSnj+9XHuk9gs9dupxRJ9TWl+atf67rLvKSF1fjQbP3JXyXHmg+pdii2QgFeMYdIzgm53fZxcHgG+Wxwi89zsGGONYnpNH7L1fhpNnLDpGqdE9VKBflNjvEroTv0vwTpyB67igAxvjCAaR8W534HoevAOPFzh5xgNjnBB0YIqTZ0KAOnAU8oS8W8iB7+ZzYCjXiUEHNiYSDCL3uN2B63rwDnyPgAPfA4xxUtCBKU6eSQHqwNHIE3KykANP5nNgKNd7gw5s3EswiNzndge+IxLvwPcJOPB9wBinBB2Y4uSZEqAOHIM8Ie8XcuD7+RwYyvWBoAMbDxAMIg+63YF1P2gHflDAgR8ExvhQ0IEpTp6HAtSBY5En5MNCDvwwnwNDuT4SdGDjEYJBZKrbHfhOgXvgqQIOPBUY46NBB6Y4eR4NUAeOQ56Qjwk58GN8Dgzl+njQgY3HCQaRJ9zuwOkCDvyEgAM/AYxxWtCBKU6eaQHqwPHIE/JJIQd+ks+BoVyfCjqw8RTBIPK02x24j4ADPy3gwE8DY5wedGCKk2e6tAOj9oZCix25H8ozkVgxSritjhFdmxlCVx4zBK88fIMxWk/IAf5ZIa7PmlxZr0ZaEQyoMwVidAw0syKbBRy0WAU1i0BQz7EIajYu0ChWQc0mENQcZIyshTof6v4Y50qd+fZrn0zuWZiK3JfyeVzSMazifJ5gFHmBRJwpSHG+iEs6llWcLxKI86VAHDnn4ZKOYxXnPAJxvhyII+cruKTjWcX5CoE4XyURZyJSnPNxSSewinM+gTgXkIgzASnOhbikE1nFuZBAnIsCceR8DZd0Eqs4XyMQ5+uBKM43cEkns4rzDQJxLiYRZyxSnEtwSaewinMJgTjfJBFnDFKcb+GSTmUV51sE4lwaiCPn27ik01jF+TaBOJcF4si5HJd0Oqs4lxOIcwWJOA2kOFfCkjZoP9GwkkCcq0jECf1C0tU4cdKuR1xNIM41gThyrsWJk3Zt41oCca4LRHGux4kzmlWc6wnEuYFDnGnQVUkbceKkXc+5kUCcm0jECV2VtBknTtr1nJsJxLklEEfOrThx0q7n3Eogzm2BOHJux4mTdj3ndgJxvkMiTujCjx04cdKu59xBIM6dJOKErufchRMn7XrOXQTi3B2II+cenDhp13PuIRDn3kAU57s4cdKu53yXQJz7SMQJXZW0HydO2vWc+wnEeYBEnNBVSQdx4qRdz3mQQJyHAnHkPIwTJ+16zsME4jwSiCPnezhx0q7nfI9AnEfRMUrtYxoGTlxqH9PM9vU+sCD6xCnp4TtxGPar/AC9GxxjoRj2gTwWLBTH/oofBgvFsb/icakLWvS1w0fgPREZBfURwZn/MYugToD3MWQU1AkCQZ1kEdQn4L0HGQX1CYGgPmUR1CnwfoGMgjpFIKjPWAT1OXiPP0ZBfU4gqC9YBPUleF8+RkF9SSCo0yyCOgPeS49RUGcIBPUVi6DOgve/YxTUWQJBnWMR1NfgPesYBfU1gaC+YRHUt+B95hgF9S2BoL5jEdR58N5wlG+9EAjqAougvgfv58YoqO8JBPVDIG788iN4PzdGcf5IIM6fSMQZhRTnz+D93BjF+TOBOC+SLOtNR4rzEng/N0ZxXiIQ5y8k4kxDivNX8H5ujOL8lUCclwNx5PwNvJ8bozh/IxCnJ0sAijMElrRBu64tJIv7YwwlEWcyUpxhOHHSrpELIxBnOIk4ofu5ReDESbveLoJAnJEk4oRu/JIFJ07atXtZCMSZlUSc0P3csuHESbsOMBuBOLMH4siZAydO2jWFOQjEmTMQxZkLJ07a9Ym5CMSZm0Sc0F2J8uDESbvWMQ+BOPOSiDMOKc58OHHSrpvMRyDO/CTijEaKswBOnLRrMAsQiLMgiTihq5IK4cRJu56zEIE4rwvEkbMwLOko2vWchQnEWSQQxXk9Tpy06zmvJxDnDRziTIUu/CiKEyftes6iBOK8kWTkhH6z+U04cdKu57yJQJzFSEZO6LdMFseJk3Y9Z3ECcZYgESd0VVJJnDhp13OWJBBnqUAcOUvjxEm7nrM0gThvDkRxlsGJk3Y9ZxkCcZYlESd04Uc5nDhp13OWIxBneRJxJiHFWQEnTtr1nBUIxFmRRJzxSHFWwomTdj1nJQJxViYRJ3RVUhWcOGnXc1YhEGfVQBw5q+HESbuesxqBOL2BKE4DJ07a9ZwGgTijSMQJXfgRjRMn7XrOaAJxxpCIE/r9vLE4cdKu54wlEGcciTih+3PGw5KOpl3PGU8gzgQScUJXJSXixEm7njORQJy3BOLIWR0nTtr1nNUJxFkjEMVZEydO2vWcNQnEWYtDnCnQhR+1ceKkXc9Zm0CcdUjECd3ZuC5OnLTrOesSiLMeiTih+3PWx4mTdj1nfQJxNiARJ3RVUkOcOGnXczYkEGejQBw5G+PESbueszGBOJsEojib4sRJu56zKYE4m5GIE7rwozlOnLTrOZsTiLMFiTihOxu3xImTdj1nSwJxtiIRJ3R/zltx4qRdz3krgThbk4gTuiqpDU6ctOs52xCIs20gjpztcOKkXc/ZjkCc7QNRnB1w4qRdz9mBQJy3kYgTuvCjIyzpGNr1nB0JxNmJRJzQnY0748RJu56zM4E4u3CIMxm6P+ftOHHSrue8nUCcXUnECV2VdAdOnLTrOe8gEGe3QBw5u+PESbueszuBOHsEojiTcOKkXc+ZRCDOZBJxQhd+pODESbueM4VAnKkk4oTubJyGEyftes40AnGmk4gTuj9nT5w4addz9iQQZy8ScUJXJfXGiZN2PWdvAnH2CcSR806cOGnXc95JIM6+gSjOfjhx0q7n7Ecgzv4k4oQu/BiAEyftes4BBOIcSCJO6M7Gg3DipF3POYhAnINJxAndn3MITpy06zmHEIhzKIk4oauShuHESbuecxiBOIcH4sg5ApZ0LO16zhEE4hwZiOIchRMn7XrOUQTiHM0hziTowo8xOHHSruccQyDOsSQjJ3Rn47tw4qRdz3kXgTjHkYyc0P05x+PESbueczyBOCeQiBO6KulunDhp13PeTSDOiYE4ct6DEyftes57CMQ5KRDFORknTtr1nJMJxHkviTihCz/uw4mTdj3nfQTinEIiTujOxvfjxEm7nvN+AnE+QCJO6P6cD+LESbue80ECcT5EIk7oqqSHceKkXc/5MIE4HwnEkXMqTpy06zmnEojz0UAU52M4cdKu53yMQJyPk4gTuvDjCZw4addzPkEgzmkk4oTubPwkTpy06zmfJBDnU+gYQ0Ci9AmpjBJltcgrxe7N3GH0Aor9aaEzHHWC/+87P4E5T8flbDjl6s3cYdRRudZFfiWl6quPauHgmiBjTI/E8esDjOsZl2tF12AwWCszVQsDa2UwsL4zgfnOAI9/EvUdAq7vcwL1HQKs73PAfJ8lqO9QcH3nCNR3KLC+c4D5ziSo7zBwfecK1HcYsL5zgfnOIqjvcHB9XxCo73BgfV8A5vscQX1HgOv7kkB9RwDr+xIw39kE9R0Jru/LAvUdCazvy8B85xDUdxS4vq8K1HcUsL6vAvOdC64veo5N12OBwBzbAiDD5wkYLhJguAjI8AUChq8LMHwdyPBFAoaLBRguBjJ8iYDhmwIM3wQynEfAcKkAw6VAhi8TMFwmwHAZkOErBAxXCDBcAWT4KgHDVQIMVwEZzidguEaA4RogwwUEDNcJMFwHZLiQgOEGAYYbgAwXETDcJMBwE5DhawQMtwgw3AJk+DoBw20CDLcBGb5BwPAdAYbvABkuJmC4U4DhTiDDJQQMdwsw3A1k+CYBw70CDPcCGb5FwHCfAMN9QIZLCRgeEGB4AMjwbQKGhwQYHgIyXEbA8IgAwyNAhssJGB4VYHgUyHCFMENv5g7D9xkOdG1i8rs7b62d9wU+M1ANuM7hGaAOVwLX+aNrGyowLjSJxGrlA4FzZFUW93NsCuZ4TIDjagKOzcAcPxTguIaAY3Mwx+MCHNcScGwB5vixAMd1BBxbgjmeFOC43uXXoDrvTwXy3kCQ92cCeW8kyPsLgbw3EeR9WiDvzQR5fyWQ9xaCvM8J5L2VIO9vBPLeRpD3dwJ5byfI+4JA3u8Q5P2DQN47CPL+SSDvnQR5XxTIexdB3r8I5L2bIO/LAnnvIcjbkwWf916CvEMF8n6XIO9wgbz3EeQdKZD3foK8swrkfYAg7+wCeR8kyDunQN6HCPLOLZD3YYK88wrkfYQg7/wCeb9HkHdBgbyPEuR9nUDe7xPkXUQg7w8I8r5BIO9jBHnfKJD3hwR5FxPI+zhB3iUE8v6IIO9SAnl/TJD3zQJ5nyDIu6xA3icJ8i4vkPcnBHlXFMj7U4K8KwvkfYog76oCeX9GkLdXIO/PCfKOEsj7C4K8YwTy/pIg7ziBvE8T5J0gkPcZgrxvEcj7K4K8awjkfZYg71oCeZ8jyLuOQN5fE+RdTyDvbwjybiCQ97cEeTcSyPs7grybCOR9niDvZgJ5XyDIu4VA3t8T5N1KIO8fCPJuLZD3jwR5txXI+yeCvNsL5P0zQd63CeR9kSDvTgJ5XyLIu4tA3r8Q5N1VIO9fCfLuJpD3ZYK8ewjk/RtB3skCeXuyuj/vVIG8QwjyThfIO5Qg714CeYcR5N1HIO9wgrz7CuQdQZB3f4G8IwnyHiiQdxaCvAcL5J2VIO+hAnlnI8h7uEDe2QnyHimQdw6CvEcL5J2TIO+xAnnnIsh7nEDeuQnyniCQdx6CvCcK5J2XIO9JAnnnI8j7XoG88xPkPUUg7wIEeT8gkHdBgrwfEsi7EEHejwjkfR1B3o8K5F2YIO/HBfIuQpD3NIG8ryfI+ymBvG8gyPtpgbyLAvPW36sQ4flzz2UdaxGP84H5m7HRMv3Gxcr0Gx/D1W9colC/aUL9xsv0G+UVqluyTL/RUvGmcvGNM4Q4CI07YhzihPqN5epX7Dxm06/UuC7lm1H6WiLE1jf6GisE15fXHiM82EYe7IVbpA0wOt7p6uL1mSz4ftMj8UX7/RvCsniuVJwEmPK4vrzWeG/MKhiw7hzd701ZgcvfhPK+KeufgEH9isTqO9tCwf1az7bM1qgY7tbTcGKY2fgqmPVGM6wAjLG4y6ctdI2LZ8XXpkRW7KAZZuau+y3h+cMA9O8iPFcebjYAyTjLkcRZ1sMxNrv9Sgh9zlb0/HFOocfTMGBfFT0yF2MlswreChQHz+FmtRTJI1Aw/X25ZSKxJ1RR4IVZ+h/HFff0gL4N3wMr31Jm7KWzmuLwuVEpUzXW35U2HUpCSD6Q6DO/bX4Z5wB9kXOUGadRCngHUhp4dQv88mUDUQvrCYLWih7MSgndZfmOMHDMN+NqHQesdVxbl38hu671zQLjTRmhu4MywmPvKoE79ibAO/ayLr/b1AxXCzBsCmRYjoDhGgGGzYAMyxMwXCvAsDmQYQUChusEGLYAMqxIwHC9AMOWQIaVCBhuEFh4VZkg740CeVchyHuTQN5VCfLeLJB3NYK8twjk7SXIe6tA3gZB3tsE8o4iyHu7QN7RBHm/I5B3DEHeOwTyjiXIe6dA3nEEee8SyDueIO/dAnknEOS9RyDvRIK89wrkfQtB3u8K5F2dIO99AnnXIMh7v0DeNQnyPiCQdy2CvA8K5F2bIO9DAnnXIcj7sEDedQnyPiKQdz2CvN8TyLs+Qd5HBfJuQJD3+wJ5NyTI+wOBvBsR5H1MIO/GBHl/KJB3E4K8jwvk3ZQg748E8m5GkPfHAnk3J8j7hEDeLQjyPimQd0uCvD8RyLsVQd6fCuR9K0HepwTybk2Q92cCebchyPtzgbzbEuT9hUDe7Qjy/lIg7/YEeZ8WyLsDQd5nBPK+jSDvrwTy7kiQ91mBvDsR5H1OIO/OBHl/LZB3F4K8vxHI+3aCvL8VyLsrQd7fCeR9B0He5wXy7kaQ9wWBvLsT5P29QN49CPL+QSDvJIK8fxTIO5kg758E8k4hyPtngbxTCfK+KJB3GkHelwTyTifI+xeBvHsS5P2rQN69CPK+LJB3b4K8fxPIuw9B3h6BvVruJMg7RCDvvgR5hwrk3Y8g7zCBvPsT5B0ukPcAgrwjBPIeSJB3pEDegwjyziKQ92CCvLMK5D2EIO9sAnkPJcg7u0DewwjyziGQ93CCvHMK5D2CIO9cAnmPJMg7t0DeowjyziOQ92iCvPMK5D2GIO98AnmPJcg7v0DedxHkXUAg73EEeRcUyHs8Qd6FBPKeQJD3dQJ5302Qd2GBvCcS5F1EIO97CPK+XiDvSQR53yCQ92Rg3npf+9Kq9TD70/u76/3J9f7aen9ovb+x3p9X71Wr923Ve5jq/Tz13pZ6n0e956He/0/vhaf3hdN7pOn9wvTeWXofKb2nkt5fSO+1o/ed0Xuw/L4fiWp6nwq9Z4Pev0B/ll9/rl1/xlt/3ll/9ld/DlZ/JlR/PlJ/VlB/bk5/hkx/nkp/tkh/zkZ/5kR//kJ/FkGvy9dr1PV6bb12Wa/j1Wta9fpOvdZRr/vTa+D0ejC9NkqvE9JrZvT6Eb2WQq8r0O+x6/eb9Xuv+n1I/Z6cfn9Kv1ej37fQc/h6PlvP7ep5Tj3np+e/9FyQnhfRcwT6flnfO+r7KH1Poa+v9bWmvu7S1yDaj7U36XFaj1n6/NVa1nX1HWgtSn3Pwr1ALYaaWrQfqP6l2CIZSMV4HzrGUHCAOmHrt1ghvkRGJ42O8z5gjFN4Th4jkE+eKegYpUb3UIF+UWK/HwhR8/N9I4/ut4RQ4Rm4PhB0YOMBgkHkQbc7cHkP3oEfFDh5HgTG+FDQgSlOnocC1IGjkCfkw0IO/DCfA0O5PhJ0YOMRgkFkqvQggnBMHWQYKPHU2JgYI9mbCvx26L9AzGy+jwbdl+LEeTRA3Tca6RKPCbnvY3zuC+X6eNB9jccJBpEn3O6++oSq6MG5r3kYYcC+KgLznQYuSCi4HnqQAIrm98FsmsB8xBPAwezJ4BURxWD2ZIBeEcUgnfspoSuip/iuiKBcnw5eERlPEwwi093+joAWZUnwOwLTBRx4OjDGZ4IOTHHyPBOgDhyLdIoZQg48g8+BoVyfDTqw8SzBIDLT7YOIXkL8TBa8Y6ZH4sQ+i2AeAVjo3wegWQJXMTOBA9BzwasYigHoOYEYfz/CwCfRbOAJFJMf11fb/FghSlytzBZYdz9H6MptjnnlFm62CM+VB5pReY/MSYCOsxxJnGVJ4pyVlSPOaWAz9R1zzc/7PK/HB3TQN6lOK3jwV1MVgH3dBDQV6yA21zKIZbUw8AjwKKOupKtFYq/4V2bBixgRY/ofR4rH4chk34bvgbVWL5gnyItZzcL6CvyC6ajW370oOOdwtaJkeofX/DIjYISgeP5jzlFmzsYLwNucF4F9Ia9KEXV1OtnQgxeyFi8BB3OJc1gb101Z8XdGUoaY2b7mubweWi/zBO6M5gldVYZj80+oBpyCexmgm7Q/xptE4DiYgPY3tAa1Vl4W0OArQnfnrwhf48wQmGoeDNT5q1ndrSfN8FkBhkOADOcTMJwpwHAokOECAoazBBgOAzJcSMDwOQGGw4EMFxEwnC3AcASQ4WsEDOcIMBwJZPg6AcO5AgxHARm+QcDweYE5sMUEeb8gkPcSgrxfFMj7TYK8XxLI+y2CvOcJ5L2UIO+XBfJ+myDvVwTyXkaQ96sCeS8nyHu+QN4rCPJeIJD3SoK8FwrkvYog70UCea8myPs1gbzXEOT9ukDeawnyfkMg73UEeS8WyHs9Qd5LBPLeQJD3mwJ5byTI+y2BvDcR5L1UIO/NBHm/LZD3FoK8lwnkvZUg7+UCeW8jyHuFQN7bgXnr9RY3e/5ca6HXHej3zfX7vvp9S/2+m37fSL/voeft9Ry2ns/Vc5t6nk/Peen5Hz0XoucF9D2yvl/U9076PkJfU+vrS32tpa87tAdrP9Jjsx6n9Dmr9atrud1cBCtRC6n1L++AV8zf7LnyQPUvxRbJQCrGHegYQ8EB6oTngRdF7hD47OYOYIw7eU4esc9uMpw8O9ExSo3uoQL9osS+S2il5C7BlZIMXHcHHdjYTTCI7HG7A5f34B14j8DJswcY496gA1OcPHsD1IGjkCfku0IO/C6fA0O57gs6sLGPYBDZ73YHLufBO/B+AQfeD4zxQNCBKU6eAwHqwNHIE/KgkAMf5HNgKNdDQQc2DhEMIofd7sB6AyC0Ax8WcODDwBiPBB2Y4uQ5EqAOHIM8Id8TcuD3+BwYyvVo0IGNowSDyPtud2C9pSHagd8XcOD3gTF+EHRgipPngwB14FjkCXlMyIGP8TkwlOuHQQc2PiQYRI673YGfF7gHPi7gwMeBMX4UdGCKk+ejAHXgOOQJ+bGQA3/M58BQrieCDmycIBhETrrdgWcJOPBJAQc+CYzxk6ADU5w8nwSoA8cjT8hPhRz4Uz4HhnI9FXRg4xTBIPKZ2x14roADfybgwJ8BY/w86MAUJ8/nAjH+foD3vTeQ+95/ARS6277/w9eXhFj0wKPZoT/3+6XQFcyXglcwvkEdPQgjjeK0ENfTJlfWq5pWke6P8QxyYGYt1CyCQn0VLJTXmE1QqLPBQnmN86Huj/Gc1DWp3asz+Z1Hqcjv3foal3QMqzi/Jrhh+oZEnClIcX6LSzqWVZzfEojzu0AcOc/jko6jtXUCcV4IxJHze1zS8azi/J5AnD+QiDMRKc4fcUknsIrzRwJx/kQizgSkOH/GJZ3IKs6fCcR5MRBHzku4pJNYxXmJQJy/BKI4f8Ulncwqzl8JxHmZRJyxSHH+hks6hVWcvxGI05ONQ5wxSHGG4JJOZRVnSDb3xxhKIk7oyBmGSzqNVZxhBOIMD8SRMwKXdDqrOCMIxBlJIk4DKc4ssKQN2pX8WQjEmZVEnF6kOLPhxGmwijMbgTizB+LImQMnzihWceYgEGfOQBRnLpw4o1nFmYtAnLk5xJkGXZWUBydO2vWceQjEmZdEnNBVSflw4qRdz5mPQJz5A3HkLIATJ+16zgIE4iwYiCNnIZw4addzFiIQ53Uk4oQu/CiMEyftes7CBOIsQiJO6HrO63HipF3PeT2BOG8IxJGzKE6ctOs5ixKI88ZAFOdNOHHSrue8iUCcxUjECV2VVBwnTtr1nMUJxFmCRJzQVUklceKkXc9ZkkCcpQJx5CyNEyftes7SBOK8ORBHzjI4cdKu5yxDIM6yUuIMxP07M9vXQ/llihFmq0Vm4yyHEw10z1IkPz3olPZceaDrE4h7U5ZHDjqshWLYm7JCsFAce1NWDBaKY2/KSsFCeY2PCM6oysFCeY0TBIWqEiyU1/iEoFBVg4XyGqcIClUtWCiv8TlBobzBQnmNLwkKZQQL5TXOEBQqKlgor3GWoFDRwUJ5ja8JChUTLJTX+JagULHBQqkpJIJCxQUL5TW+JyhUfCB+qD4BvFcOozgTCN74TyQRZxRSnLeA98phFOctBOKsTrJkKh0pzhrgvXIYxVmDQJw1ScSZhhRnLfBeOYzirEUgztqBOHLWAe+VwyjOOgTirBuI4qwH3iuHUZz1CMRZn0ScyUhxNgDvlcMozgYE4mwYiHvlNALvlcMozkYE4mwciB+qbwLeK4dRnE0IxNk0EPfKaQbeK4dRnM0IxNk8EEfOFuC9chjF2YJAnC0DUZytwHvlUH6EkECctwbijg+twXvlMIqzNYE425CIMw4pzrbgvXIYxdmWQJztSMQZjRRne/BeOYzibE8gzg4k4oSuSroNvFcOozhvIxBnx0AcOTvBko6iXc/ZiUCcnQNRnF1w4qRdz9mFQJy3c4gzFbrwoytOnLTrObsSiPMOkpET+q2x3XDipF3P2Y1AnN1JRk7oN3j1wImTdj1nDwJxJpGIE7oqKRknTtr1nMkE4kwJxJEzFSdO2vWcqQTiTAtEcabjxEm7njOdQJw9ScQJXfjRCydO2vWcvQjE2ZtEnElIcfbBiZN2PWcfAnHeSSLOeKQ4++LESbuesy+BOPuRiBO6Kqk/Tpy06zn7E4hzQCCOnANx4qRdzzmQQJyDAlGcg3HipF3POZhAnENIxAld+DEUJ07a9ZxDCcQ5jESc0O8+HI4TJ+16zuEE4hxBIk7o/pwjYUlH067nHEkgzlEk4oSuShqNEyftes7RBOIcE4gj51icOGnXc44lEOddgSjOcThx0q7nHEcgzvEc4kyBLvyYgBMn7XrOCQTivJtEnNCdjSfixEm7nnMigTjvIREndH/OSThx0q7nnEQgzskk4oSuSroXJ07a9Zz3EojzvkAcOafgxEm7nnMKgTjvD0RxPoATJ+16zgcIxPkgiTihCz8ewomTdj3nQwTifJhEnNCdjR/BiZN2PecjBOKcSiJO6P6cj+LESbue81ECcT5GIk7oqqTHceKkXc/5OIE4nwjEkXMaTpy06zmnEYjzyUAU51M4cdKu53yKQJxPk4gTuvBjOizpGNr1nNMJxPkMiTihOxvPwImTdj3nDAJxPsshzmTo/pwzceKkXc85k0Ccs0jECV2V9BxOnLTrOZ8jEOfsQBw55+DESbuecw6BOOcGojifx4mTdj3n8wTifIFEnNCFHy/ixEm7nvNFAnG+RCJO6M7G83DipF3POY9AnC+TiBO6P+crOHHSrud8hUCcr5KIE7oqaT5OnLTrOecTiHNBII6cC3HipF3PuZBAnIsCUZyv4cRJu57zNQJxvk4iTujCjzdw4qRdz/kGgTgXk4gTurPxEpw4addzLiEQ55sk4oTuz/kWTpy06znfIhDnUhJxQlclvY0TJ+16zrcJxLksEEfO5bCkY2nXcy4nEOeKQBTnSpw4addzriQQ5yoOcSZBF36sxomTdj3nagJxriEZOaE7G6/FiZN2PedaAnGuIxk5oftzrseJk3Y953oCcW4gESd0VdJGnDhp13NuJBDnpkAcOTfjxEm7nnMzgTi3BKI4t+LESbuecyuBOLeRiBO68GM7Tpy06zm3E4jzHRJxQnc23oETJ+16zh0E4txJIk7o/py7cOKkXc+5i0Ccu0nECV2VtAcnTtr1nHsIxLk3EEfOd3HipF3P+S6BOPcFojj348RJu55zP4E4D5CIE7rw4yBOnLTrOQ8SiPMQiTihOxsfxomTdj3nYQJxHpESZzg40NlAcb6XDddXTH5cX23zyxQDNVD44kQOFEdxAjSccvVm7jCKqVyLA/PVfc3NeuX5gegX1desrDh+c4Fxve9yregavArWyhnVwsBaeRVY3zPAfD8Am5FEfeeD6/uVQH3nA+v7FTDfYwT1XQCu71mB+i4A1vcsMN8PCeq7EFzfcwL1XQis7zlgvscJ6rsIXN9vBOq7CFjfb4D5fkRQ39fA9f1OoL6vAev7HTDfjwnq+zq4vhcE6vs6sL4XgPmeIKjvG+D6/iBQ3zeA9f0BmO9JgvouBtf3J4H6LgbW9ydgvp8Q1HcJuL4XBeq7BFjfi8B8PyWo75vg+v4iUN83gfX9BZjvKYL6vgWu72WB+r4FrO9lYL6fEdR3Kbi+nmz4+i4F1tcDfC/vc4L6vg2ub6hAfd8G1jcUWN8vCOq7DFzfcIH6LgPWNxxY3y8J6rscXN9IgfouB9Y3Eljf0wT1XQGub1aB+q4A1jcrsL5nCOq7Elzf7AL1XQmsb3Zgfb8iqO8qcH1zCtR3FbC+OYH1PUtQ39Xg+uYWqO9qYH1zA+t7jqC+a8D1zStQ3zXA+uYF1vdrgvquBdc3v0B91wLrmx9Y328I6rsOXN+CAvVdB6xvQWB9vyWo73pwfa8TqO96YH2vA9b3O4L6bgDXt4hAfTcA61sEWN/zBPXdCK7vDQL13Qis7w3A+l4gqO8mcH1vFKjvJmB9bwTW93uC+m4G17eYQH03A+tbDFjfHwjquwVc3xIC9d0CrG8JYH1/JKjvVnB9SwnUdyuwvqWA9f2JoL7bwPW9WaC+24D1vRlY358J6rsdXN+yAvXdDqxvWWB9L4Lri95MQdejnEA9LgEZ9gLuV/BQftnzDXJ+ZMXWt3y2K3WT2Th/yeZ+juXAHCsIcPyVgGN5MMeKAhwvE3CsAOZYSYDjbwQcK4I5Vhbg6Mnufo6VwByrCHAMIeBYGcyxqgDHUAKOVcAcqwlwDCPgWBXM0SvAMZyAYzUwR0OAYwQBRy+YY5QAx0gCjgaYY7QAxywEHKPAHGMEOGYl4BgN5hgrwDEbAccYMMc4AY7ZCTjGgjnGC3DMQcAxDswxUYBjTgKO8WCO1QU45iLgmADmWFOAY24CjolgjrUFOOYh4HgLmGNdAY55CThWB3OsL8AxHwHHGmCODQU45ifgWBPMsbEAxwIEHGuBOTYV4FiQgGNtMMfmAhwLEXCsA+bYUoDjdQQc64I53irAsTABx3pgjm0EOBYh4FgfzLGdAMfrCTg2AHPsIMDxBgKODcEcOwpwLErAsRGYY2cBjjcScGwM5ni7AMebCDg2AXO8Q4BjMQKOTcEcuwtwLE7AsRmYY5IAxxIEHJuDOaYIcCxJwLEFmGOaAMdSBBxbgjn2FOBYmoBjKzDH3gIcbybgeCuY450CHMsQcGwN5thPgGNZAo5twBwHCHAsR8CxLZjjIAGO5Qk4tgNzHCLAsQIBx/ZgjsMEOFYk4NgBzHGEAMdKBBxvA3McJcCxMgHHjmCOYwQ4ViHg2AnM8S4BjlUJOHYGcxwvwLEaAccuYI53C3D0EnC8HczxHgGOBgHHrmCOkwU4RhFwvAPM8T4BjtEEHLuBOd4vwDGGgGN3MMcHBTjGEnDsAeb4sADHOAKOSWCOUwU4xhNwTAZzfEyAYwIBxxQwxycEOCYScEwFc3xSgOMtBBzTwByfFuBYnYBjOpjjMwIcaxBw7Anm+KwAx5oEHHuBOc4S4FiLgGNvMMfZAhxrE3DsA+Y4V4BjHQKOd4I5viDAsS4Bx75gji8JcKxHwLEfmOPLAhzrE3DsD+b4qgDHBgQcB4A5LhDg2JCA40Awx0UCHBsRcBwE5vi6AMfGBBwHgzkuFuDYhIDjEDDHNwU4NiXgOBTMcakAx2YEHIeBOS4T4NicgONwMMcVAhxbEHAcAea4SoBjSwKOI8Ec1whwbEXAcRSY4zoBjrcScBwN5rhBgGNrAo5jwBw3CXBsQ8BxLJjjFgGObQk43gXmuE2AYzsCjuPAHN8R4NiegON4MMedAhw7EHCcAOa4W4DjbQQc7wZz3CvAsSMBx4lgjvsEOHYi4HgPmOMBAY6dCThOAnM8JMCxCwHHyWCORwQ43g7mKPF95O8J5N0VmHe46iOLJXfrgeZRBdeX1xrvHdkFA9ado/vtlh0nBqm8u2X/EzCoX5FYj6oT7P1sVw6C3swdxqysuBp1x52whhPDTH/g3aw3mmFVYIw9XD7Y6xr3yI6vTVJ27KAZZuau+y2h/g03fxfhufJwswFIxlmZJM5KHo6xGd3vrKyyeWd64wvPH+cUejwNA/ZVzSNzMZZsGQPhhe8BvvLNaimSxywaMt5qkR5PmUhcf9PVpXrRrNgTtCvwQi/9j+Mvgx6ob8P3wFqvFDP21Oym2HzulmKq0Pq7VNPxJITpA4keSfYXlHGiCEycUWacRgrwjiYVeLUckx/XV1tgX4i6Wk82tO70QJsidAfoO8LBMafhdBMH1E0cUDdx6PFAwqDTBMbBdKG7oHRhT/hFYGaiLHBmoqfL76o1w18FGJYDMuxFwPCyAMPyQIa9CRj+JsCwApBhHwKGHoFZxopAhncSMAwRYFgJyLAvAcNQAYaVgQz7ETAME2BYBciwPwHDcIl3XYAMBxAwjBBgWA3IcCABw0gBhl4gw0EEDLMIMDSADAcTMMwqwDAKyHAIAcNsAgyjgQyHEjDMLsAwBshwGAHDHAIMY4EMhxMwzCnAMA7IcAQBw1wCDOOBDEcSMMwtwDAByHAUAcM8AgwTgQxHEzDMK8DwFiDDMQQM8wkwrA5kOJaAYX4BhjWADO8iYFhAgGFNIMNxBAwLCjCsBWQ4noBhIQGGtYEMJxAwvE6AYR0gw7sJGBYWYFgXyHAiAcMiAgzrARneQ8DwegGG9YEMJxEwvEGAYQMgw8kEDIsKMGwIZHgvAcMbBRg2AjK8j4DhTQIMGwMZTiFgWEyAYRMgw/sJGBYXYNgUyPABAoYlBBg2AzJ8kIBhSQGGzYEMHyJgWEqAYQsgw4cJGJYWYNgSyPARAoY3CzBsBWQ4lYBhGQGGtwIZPkrAsKwAw9ZAho8RMCwnwLANkOHjBAzLCzBsC2T4BAHDCgIM2wEZTiNgWFGAYXsgwycJGFYSYNgByPApAoaVBRjeBmT4NAHDKgIMOwIZTidgWFWAYScgw2cIGFYTYNgZyHAGAUOvAMMuQIbPEjA0BBjeDmQ4k4BhlADDrkCGswgYRgswvAPI8DkChjECDLsBGc4mYBgrwLA7kOEcAoZxAgx7ABnOJWAYL8AwCcjweQKGCQIMk4EMXyBgmCjAMAXI8EUChrcIMEwFMnyJgGF1AYZpQIbzCBjWEGCYDmT4MgHDmgIMewIZvkLAsJYAw15Ahq8SMKwtwLA3kOF8AoZ1BBj2ATJcQMCwrgDDO4EMFxIwrCfAsC+Q4SIChvUFGPYDMnyNgGEDAYb9gQxfJ2DYUIDhACDDNwgYNhJgOBDIcDEBw8YCDAcBGS4hYNhEgOFgIMM3CRg2FWA4BMjwLQKGzQQYDgUyXErAsLkAw2FAhm8TMGwhwHA4kOEyAoYtBRiOADJcTsCwlQDDkUCGKwgY3irAcBSQ4UoChq0FGI4GMlxFwLCNAMMxQIarCRi2FWA4FshwDQHDdgIM7wIyXEvAsL0Aw3FAhusIGHYQYDgeyHA9AcPbBBhOADLcQMCwowDDu4EMNxIw7CTAcCKQ4SYChp0FGN4DZLiZgGEXAYaTgAy3EDC8XYDhZCDDrUCG+vuYy6jWw+xPfy+x/l5d/b2w+ntN9fdy6u+V1N+LqL/XT38vnf5eNf29YPp7rfT3MunvFdLfi6O/10V/L4n+Xg39vRD6ew30vvx6X3m9L7re11vvS633Vdb7Aut9bfW+rHpfUb0vpt7XUe9LqPfV0/vC6X3N9L5cel8pvS+S3tdH70uj91XR+4LofS30vgx6XwH9uXj9uW79uWT9uVr9uVD9uUb9uTz9uTL9uSj9uR79uRT9uQr9uQC9rl2vy9brivW6WL2uU69L1Ovq9Lowva5Jr8vR60r0ugj9vr5+X1q/r6rfF9Tva+n3ZfT7CnpeXM/r6nlJPa+m54X0vIa+L9f3lfq+SF/X6+tSfV2lrwu0r+lxWY8r+rzQdfUdLN8Pvg2oxVBTi/YD1b8UWyQDqRi3o2NED5A64R7ZccLUfW0XGMi3A2N8h+fkMaSEyXDyvIOOUWp0DxXoFyX2HUCIml+YyVH3W0Ko8AxcdwYd2NhJMIjscrsDV/HgHXiXwMmzCxjj7qADU5w8uwPUgaOQJ+QeIQfew+fAUK57gw5s7CUYRN6VHkQQjqmDDAMlnhobE2Mke1N7ZJeBmNl89wXdl+LE2Reg7huNdIn9Qu67n899oVwPBN3XOEAwiBx0u/vqE6qaB+e+5mGEAfuqBsz3ELggoeB66EECKJrfB7NDAvMRB4GD2eHgFRHFYHY4QK+IYpDOfUToiugI3xURlOt7wSsi4z2CQeSo298R0KJMBr8jcFTAgY8CY3w/6MAUJ8/7AerAsUin+EDIgT/gc2Ao12NBBzaOEQwiH7p9ENHLkd/PhnfMWcDlyMcJ5hGAhf59ADoucBXzIXAA+ih4FUMxAH0kEOPvR7gHexJ9DDyBYvLj+moL7Gt/QayoJa58PhZYw39C6CrwhHkVGG62CM+VB5pRFY/MCYWOszJJnJVI4jyenSPOQ2Bj9h0nzc8OfaLHB3TQ3VSnVT34K7OqwL66AQ3KOoidtAxiWS0MPJ4r3ynMbA5lItU7kJG4PKZn8XhWZsHejVzKhj8pEDmn/3GkeByOTPZt+B5Ya/+pecKdym4KxSeYT02Htv7ulOB8yNWKklkxni4oM6JGCornP+YcZeZsfAq8BTsF7At5xdwL2BdCI04nLtpokHX9DGg0EuOBNtVu2fHmJGXWme3rc5fXQ+vlc4G7ts+FrnjDsfknAMbn6LQ/xohE4DiYYB0HM1uLc0JeiT6Hv8BpJgF4fWCg+aHPYX2ufSFwDn8pNPPypfD15gcCb0m8CnxL4nR2d+tJMzwmwHA+kOEZAoYfCjBcAGT4FQHD4wIMFwIZniVg+JEAw0VAhucIGH4swPA1IMOvCRieEGD4OpDhNwQMTwowfAPI8FsChp8IMFwMZPgdAcNPBRguATI8T8DwlADDN4EMLxAw/EyA4VtAht8TMPxcgOFSIMMfCBh+IcDwbSDDHwkYfinAcBmQ4U8EDE8LMFwOZPgzAcMzAgxXABleJGD4lQDDlUCGlwgYnhVguArI8BcChucEGK4GMvyVgOHXAgzXABleJmD4jQDDtUCGvxEw/FaA4TogQ08O9zP8ToDheiDDEAKG5wUYbgAyDCVgeEGA4UYgwzACht8LMNwEZBhOwPAHAYabgQwjCBj+KMBwC5BhJAHDnwQYbgUyzELA8GcBhtuADLMSMLwowHA7kGE2IEO9HrGs58+1iHpdnl5XptdF6XU9el2KXleh1wXo97X1+7L6fUX9vph+X0e/L6Hn1fW8sJ7X1PNyel5Jz4vo+3p9X6rvq/R9gb6u1ddl+rpC+6Ie1/W4pM8rrQudl+9gWR+aHViLULMW9gPVvxTb7DncH2MOdIzoAUIn/Dn4Qxc6aXScVpCZjTEnz8kjtgcGw8mTEx2j1OgeKtAvSuy5gBCtnyTQ/ZYQKjwD19xBBzZyEwwiedzuwHpjErQD5xFw4DxAB84bdGCKkydvgDpwFPKEzCfkwPn4HBjKNX/QgY38BINIAbc7sN5yC+3ABQQcuADQgQsGHZji5CkYoA4cjTwhCwk5cCE+B4ZyvS7owMZ1BINIYbc78KHseAcuLODAhYEOXCTowBQnT5EAdeAY5Al5vZADX8/nwFCuNwQd2LiBYBAp6nYHruTBO3BRAQcuCnTgG4MOTHHy3BigDhyLPCFvEnLgm/gcGMq1WNCBjWIEg0hxtzvwJwL3wMUFHLg40IFLBB2Y4uQpEaAOHIc8IUsKOXBJPgeGci0VdGCjFMEgUtrtDnxcwIFLCzhwaaAD3xx0YIqT5+YAdeB45AlZRsiBy/A5MJRr2aADG2UJBpFybnfgkwIOXE7AgcsBHbh80IEpTp7yAjH+fqC/y6UCLtC/fI9XVFJsfEpMUowKJzkuJSomwYiJi05JT082Yo2o1FgjIToqNS45Oj0uKSEqJio+3UiOU1GnGfFRf/R1zuXfoqsHC80O/VndikJXHRUFrzp8AzF64EQO7pWEuFYyubJeibSKdH+MlZGDKWuhZhEUqkqwUF5jNkGhqgYL5TXOh7o/xmpS15F2r87kdyqmIr+L04tLOoZVnF6CmxyDRJwpSHFG4ZKOZRVnFIE4owNx5IzBJR3HKs4YAnHGBuLIGYdLOp5VnHEE4ownEWciUpwJuKQTWMWZQCDORBJxJiDFeQsu6URWcd5CIM7qgThy1sAlncQqzhoE4qwZiOKshUs6mVWctQjEWZtEnLFIcdbBJZ3CKs46BOKsSyLOGKQ46+GSTmUVZz0CcdYPxJGzAS7pNFZxNiAQZ8NAHDkb4ZJOZxVnIwJxNiYRp4EUZxNY0gbt6vsmBOJsSiJOL1KczXDiNFjF2YxAnM0DceRsgRNnFKs4WxCIs2UgirMVTpzRrOJsRSDOWznEmQZdldQaJ07a9ZytCcTZhkSc0FVJbXHipF3P2ZZAnO0CceRsjxMn7XrO9gTi7BCII+dtOHHSrue8jUCcHUnECV340QknTtr1nJ0IxNmZRJzQ9ZxdcOKkXc/ZhUCctwfiyNkVJ07a9ZxdCcR5RyCKsxtOnLTrObsRiLM7iTihq5J64MRJu56zB4E4k0jECV2VlIwTJ+16zmQCcaYE4siZihMn7XrOVAJxpgXiyJmOEyftes50AnH2lBJnODjQapE4cVYAbi4bkx/XV95CMsWw1yKzcfYC7n/aKz+ur9PA/U+RtdADWBnPlQe61oG4z2Vv9K58jIVi2OeyT7BQHPtc3hksFMc+l32DhfIaHxGcUf2ChfIaJwgK1T9YKK/xCUGhBgQL5TVOERRqYLBQXuNzgkINChbKa3xJUKjBwUJ5jTMEhRoSLJTXOEtQqKHBQnmNrwkKNSxYKK/xLUGhhgcLpaaQCAo1Ilgor/E9QaFGBuIH9EeB991hFOcogkUEo0nEGYUU5xjwvjuM4hxDIM6xJMuv0pHivAu87w6jOO8iEOc4EnGmIcU5HrzvDqM4xxOIc0Igjpx3g/fdYRTn3QTinBiI4rwHvO8OozjvIRDnJBJxJiPFORm87w6jOCcTiPPeQNx35z7wvjuM4ryPQJxTAvED+veD991hFOf9BOJ8IBD33XkQvO8OozgfJBDnQ4E4cj4M3neHUZwPE4jzkUAU51TwvjuM4pxKIM5HA3H3iMfA++4wivMxAnE+TiLOOKQ4nwDvu8MozicIxDmNRJzRSHE+Cd53h1GcTxKI8ykScUJXJT0N3neHUZxPE4hzeiCOnM/Ako6iXc/5DIE4ZwSiOJ/FiZN2PeezBOKcySHOVOjCj1k4cdKu55xFIM7nSEZO6DfQzsaJk3Y952wCcc4hGTmh3wY2FydO2vWccwnE+TyJOKGrkl7AiZN2PecLBOJ8MRBHzpdw4qRdz/kSgTjnBaI4X8aJk3Y958sE4nyFRJzQhR+v4sRJu57zVQJxzicRZxJSnAtw4qRdz7mAQJwLScQZjxTnIpw4addzLiIQ52sk4oSuSnodJ07a9ZyvE4jzjUAcORfjxEm7nnMxgTiXBKI438SJk3Y955sE4nyLRJzQhR9LceKkXc+5lECcb5OIE/o9istw4qRdz7mMQJzLScQJ3Z9zBSzpaNr1nCsIxLmSRJzQVUmrcOKkXc+5ikCcqwNx5FyDEyftes41BOJcG4jiXIcTJ+16znUE4lzPIc4U6MKPDThx0q7n3EAgzo0k4oTubLwJJ07a9ZybCMS5mUSc0P05t+DESbuecwuBOLeSiBO6KmkbTpy06zm3EYhzeyCOnO/gxEm7nvMdAnHuCERx7sSJk3Y9504Cce4iESd04cdunDhp13PuJhDnHhJxQnc23osTJ+16zr0E4nyXRJzQ/Tn34cRJu55zH4E495OIE7oq6QBOnLTrOQ8QiPNgII6ch3DipF3PeYhAnIcDUZxHcOKkXc95hECc75GIE7rw4ygs6Rja9ZxHCcT5Pok4oTsbf4ATJ+16zg8IxHmMQ5zJ0P05P8SJk3Y954cE4jxOIk7oqqSPcOKkXc/5EYE4Pw7EkfMETpy06zlPEIjzZCCK8xOcOGnXc35CIM5PScQJXfhxCidO2vWcpwjE+RmJOKE7G3+OEyftes7PCcT5BYk4oftzfokTJ+16zi8JxHmaRJzQVUlncOKkXc95hkCcXwXiyHkWJ07a9ZxnCcR5LhDF+TVOnLTrOb8mEOc3JOKELvz4FidO2vWc3xKI8zsScUJ3Nj6PEyftes7zBOK8QCJO6P6c3+PESbue83sCcf5AIk7oqqQfceKkXc/5I4E4fwrEkfNnWNKxtOs5fyYQ58VAFOclnDhp13NeIhDnLxziTIIu/PgVJ07a9Zy/EojzMsnICd3Z+DecOGnXc/5GIE5PTo6RE7o/Zwgs6Vja9ZwhOd0fYyiJOKGrksJw4qRdzxlGIM7wQBw5I3DipF3PGUEgzshAFGcWnDhp13NmIRBnVhJxQhd+ZMOJk3Y9ZzYCcWYnESd0Z+McOHHSrufMQSDOnCTihO7PmQsnTtr1nLkIxJmbRJzQVUl5cOKkXc+Zh0CceQNx5MyHEyftes58BOLMH4jiLIATJ+16zgIE4ixIIk7owo9COHHSrucsRCDO60jECd3ZuDBOnLTrOQsTiLOIlDgjwIF+DBTn9TlxfcXkx/XVFtjX/oIyhUUNOr44kYPODTgxG065ejN3GN1Vrj2A+eq+TqoWDq4JMsbj2XH8TgLjKupyreganAZrpXIOjycMrJXTwPpWzoGL60awsUnU9wy4vlUE6nsGWN8qwPreRFDfr8D1rSpQ36+A9a0KrG8xgvqeBde3mkB9zwLrWw1Y3+IE9T0Hrq8hUN9zwPoawPqWIKjv1+D6RgvU92tgfaOB9S1JUN9vwPWNFajvN8D6xgLrW4qgvt+C6xsvUN9vgfWNB9a3NEF9vwPXN1Ggvt8B65sIrO/NBPU9D65vdYH6ngfWtzqwvmUI6nsBXN+aAvW9AKxvTWB9yxLU93twfWsL1Pd7YH1rA+tbjqC+P4DrW1egvj8A61sXWN/yBPX9EVzf+gL1/RFY3/rA+lYgqO9P4Po2FKjvT8D6NgTWtyJBfX8G17exQH1/Bta3MbC+lQjqexFc36YC9b0IrG9TYH0rE9T3Eri+zQXqewlY3+bA+lYhqO8v4Pq2FKjvL8D6tgTWtypBfX8F1/dWgfr+CqzvrcD6ViOo72VwfdsI1PcysL5tgPX1EtT3N3B92wnU9zdgfdsB62sQ1NeTA1vfDgL19eA24DM6APONIqhvCLi+HQXqGwKsb0dgvtEE9Q0F17ezQH1DgfXtDMw3hqC+YeD63i5Q3zBgfW8H5htLUN9wcH3vEKhvOLC+dwDzjSOobwS4vt0F6hsBrG93YL7xBPWNBNc3SaC+kcD6JgHzTSCobxZwfVME6psFWN8UYL6JBPXNCq5vmkB9swLrmwbM9xaC+mYD17enQH2zAevbE5hvdXB90Rsz6Hr0yoH/bHcN4N4HvYD7FZwuiOsrbyHZcxdyrmXHaqV3jis1mNk4a+Z0P8deYI59BDjWIuDYG8zxTgGOtQk49gFz7CvAsQ4BxzvBHPsJcKxLwLEvmGN/AY71CDj2A3McIMCxPgHH/mCOAwU4NiDgOADMcZAAx4YEHAeCOQ4W4NiIgOMgMMchAhwbE3AcDOY4VIBjEwKOQ8AchwlwbErAcSiY43ABjs0IOA4DcxwhwLE5AcfhYI4jBTi2IOA4AsxxtADHlgQcR4I5jhXg2IqA4ygwx3ECHG8l4DgazHGCAMfWBBzHgDlOFODYhoDjWDDHSQIc2xJwvAvM8V4Bju0IOI4Dc5wiwLE9AcfxYI4PCHDsQMBxApjjQwIcbyPgeDeY4yMCHDsScJwI5vioAMdOBBzvAXN8XIBjZwKOk8Acpwlw7ELAcTKY41MCHG8n4HgvmON0AY5dCTjeB+Y4Q4DjHQQcp4A5zhTg2I2A4/1gjs8JcOxOwPEBMMc5Ahx7EHB8EMzxeQGOSQQcHwJzfFGAYzIBx4fBHOcJcEwh4PgImOMrAhxTCThOBXOcL8AxjYDjo2COCwU4phNwfAzM8TUBjj0JOD4O5viGAMdeBByfAHNcIsCxNwHHaWCObwlw7EPA8Ukwx7cFON5JwPEpMMflAhz7EnB8GsxxpQDHfgQcp4M5rhbg2J+A4zNgjmsFOA4g4DgDzHG9AMeBBByfBXPcKMBxEAHHmWCOmwU4DibgOAvMcasAxyEEHJ8Dc9wuwHEoAcfZYI47BDgOI+A4B8xxlwDH4QQc54I57hHgOIKA4/Ngju8KcBxJwPEFMMf9AhxHEXB8EczxoADH0QQcXwJzPCzAcQwBx3lgju8JcBxLwPFlMMf3BTjeRcDxFTDHYwIcxxFwfBXM8bgAx/EEHOeDOX4swHECAccFYI4nBTjeTcBxIZjjpwIcJxJwXATm+JkAx3sIOL4G5viFAMdJBBxfB3M8LcBxMgHHN8AcvxLgeC8Bx8VgjucEON5HwHEJmOM3AhynEHB8E8zxOwGO9xNwfAvM8YIAxwcIOC4Fc/xBgOODBBzfBnP8SYDjQwQcl4E5XhTg+DABx+Vgjr8IcHyEgOMKMMfLAhynEnBcCeboyYnn+CgBx1VgjqECHB8j4LgazDFcgOPjBBzXgDlGCnB8goDjWjDHrAIcpxFwXAfmmF2A45MEHNeDOeYU4PgUAccNYI65BTg+TcBxI5hjXgGO0wk4bgJzzC/A8RkCjpvBHAsKcJxBwHELmON1AhyfJeC4FcyxiADHmQTfbX69QN6zgHnr713PYsndeqB5ROH68lrjfS6nYMDP5cT3Oxv45fRSec/O+SdgUL8isd6g4iya88pB0Ju5wzieHVejObgT1nBimNn4os16oxlGA2Oc6/LBXtd4rsBg/3xO7KAZZuau+y2h/g03fxfhufJwswFIxmmQxOn1cIzN6H6PZ5fNO7PnbIznj3MKPZ6GAfuK8chcjL1gqTe88HPBV75ZLUXSRzg43mqRHk+ZSFx/09WletGsuP6OZvN4umbHnvCzgBeO6X8cfxlEQX0bvgfW+r9oxv5STlO8Prd80VS19XcvmQ4qIXQfSPhXeBSWcbZITJxRZpzGi8A7pJeAV98x+XF9tQX2tb8gri+ERqwnLlrD2gReFLo79R1gI4gD6iYOqJs4q24yW5duQmNLGFg/83DjQRxwPDXQ/CQuvuYJeNLLQne4Lwv7c02BGZOewFmnV1w+Y6IZ1hJg2AvI8FUChrUFGPYGMpxPwLCOAMM+QIYLCBjWFWB4J5DhQgKG9QQY9gUyXETAsL4Aw35Ahq8RMGwgwLA/kOHrBAwbCjAcAGT4BgHDRgIMBwIZLiZg2FiA4SAgwyUEDJsIMBwMZPgmAcOmAgyHABm+RcCwmQDDoUCGSwkYNhdgOAzI8G0Chi0EGA4HMlxGwLClAMMRQIbLCRi2EmA4EshwBQHDWwUYjgIyXEnAsLUAw9FAhqsIGLYRYDgGyHA1AcO2AgzHAhmuIWDYToDhXUCGawkYthdgOA7IcB0Bww4CDMcDGa4nYHibAMMJQIYbCBh2FGB4N5DhRgKGnQQYTgQy3ETAsLMAw3uADDcTMOwiwHASkOEWAoa3CzCcDGS4lYBhVwGG9wIZbiNgeIcAw/uADLcTMOwmwHAKkOE7BAy7CzC8H8hwBwHDHgIMHwAy3EnAMEmA4YNAhrsIGCYLMHwIyHA3AcMUAYYPAxnuIWCYKsDwESDDvQQM0wQYTgUyfJeAYboAw0eBDPcRMOwpwPAxIMP9BAx7CTB8HMjwAAHD3gIMnwAyPEjAsI8Aw2lAhocIGN4pwPBJIMPDBAz7CjB8CsjwCAHDfgIMnwYyfI+AYX8BhtOBDI8SMBwgwPAZIMP3CRgOFGA4A8jwAwKGgwQYPgtkeIyA4WABhjOBDD8kYDhEgOEsIMPjBAyHCjB8DsjwIwKGwwQYzgYy/JiA4XABhnOADE8QMBwhwHAukOFJAoYjBRg+D2T4CQHDUQIMXwAy/JSA4WgBhi8CGZ4iYDhGgOFLQIafETAcK8BwHpDh5wQM7xJg+DKQ4RcEDMcJMHwFyPBLAobjBRi+CmR4moDhBAGG84EMzxAwvFuA4QIgw68IGE4UYLgQyPAsAcN7BBguAjI8R8BwkgDD14AMvyZgOFmA4etAht8QMLxXgOEbQIbfEjC8T4DhYiDD7wgYThFguATI8DwBw/sFGL4JZHiBgOEDAgzfAjL8noDhgwIMlwIZ/kDA8CEBhm8DGf5IwPBhAYbLgAx/ImD4iADD5UCGPxMwnCrAcAWQ4UUCho8KMFwJZHiJgOFjAgxXARn+QsDwcQGGq4EMfyVg+IQAwzVAhpcJGE4TYLgWyPA3AoZPCjBcB2ToyeV+hk8JMFwPZBhCwPBpAYYbgAxDCRhOF2C4EcgwjIDhMwIMNwEZhhMwnCHAcDOQYQQBw2cFGG4BMowkYDhTgOFWIMMsQIb6+5jLqdbD7E9/L7H+Xl39vbD6e03193Lq75XU34uov9dPfy+d/l41/b1g+nut9Pcy6e8V0t+Lo7/XRX8vif5ejZWq6e810Pvy633l9b7oel9vvS+13ldZ7wus97XV+7LqfUX1vph6X0e9L6HeV0/vC6f3NdP7cul9pfS+SHpfH70vjd5XRe8Love10Psy6H0F9Ofi9ee69eeS9edq31dNf65Rfy5Pf65Mfy5Kf65Hfy5Ff65Cfy5Ar2vX67L1umK9Llav69TrEvW6Or0uTK9r0uty9LoSvS5Cv6+v35fW76vq9wX1+1r6fRn9voKeF9fzunpeUs+r6XkhPa+h78v1faW+L9LX9fq6VF9X6esC7Wt6XNbjij4vdF19B8v3g2cFajHU1KL9QPUvxTZrLvfHmA0dI3qA1AnPzYkTpu5LJ42O0woyszFm5zl5DClhMpw82dExSo3uoQL9osSeAwhR8wszOep+SwgVnoFrzqADGzkJBpFcbnfgKA/egXMJOHAuoAPnDjowxcmTO0AdOAp5QuYRcuA8fA4M5Zo36MBGXoJBJJ/0IIJwTB1kGCjx1NiYGCPZmzo3pwzEzOabP+i+FCdO/gB132ikSxQQct8CfO4L5Vow6L5GQYJBpJDb3VefUDEenPuahxEG7CsGmO914IKEguuhBwmgaH4fzK4TmI8oBLwiKhy8IqIYzAoH6BVRDNK5iwhdERXhuyKCcr0+eEVkXE8wiNzg9ncEtChfAL8jcIOAA98AdOCiQQemOHmKBqgDxyKd4kYhB76Rz4GhXG8KOrBxE8EgUsztg4hejlxUYAHKceBy5OIE8wjFwPMIxQWuYooBr2JKBK9iKAagEgIx/n6EgU+iksATqEvhP/uKSoiNToxLjjW86WnJ3qiolJiYqLSYlKgUI8Yw0tIT1MPkGCPRSE5KiY2OjopOTkg0koz05JiEP/rqVhgrRImrFc0OPVldSujKrZR55RZutgjPlQeaUZRH5iRAx2mQxOklibN4Lo44rwObqe8obX7e52Y9PqCDnq0GnmgP/moqGtjXbOC6FOsgVtoyiGW1MPCYv0PyKBPp8VSLxOUxPYvHszILrr+j2TyeS9mwdyQ1cuJPMgTD9D+OFI/Dkcm+Dd8Dq5bKmCdw2Vym8HwCLGM6vvV3ZQXnRK5WlMyKe2hhmREafRLG5Mex7AXs63RBXI7DhWoRAdai9UT+jzlHmTkbZYC3xGWBdzDA88JA1NVp4EMbP7IW5YC10H2gx1N9kaMvTtB30VIXT5ntq7zL66H1Ul7gLrp8Lg5/q4CLM8HqSd7MHcY5XF8J6GsNtAa1VioIaLCi0ExOReHrzRsF3pY4DXxbohLBTjM3CTA8A2RYmYBhMQGGXwEZViFgWFyA4Vkgw6oEDEsIMDwHZFiNgGFJAYZfAxl6CRiWEmD4DZChQcCwtADDb4EMowgY3izA8Dsgw2gChmUEGJ4HMowhYFhWgOEFIMNYAoblBBh+D2QYR8CwvADDH4AM4wkYVhBg+COQYQIBw4oCDH8CMkwkYFhJgOHPQIa3EDCsLMDwIpBhdQKGVQQYXgIyrEHAsKoAw1+ADGsSMKwmwPBXIMNaBAy9AgwvAxnWJmBoCDD8DciwDgHDKAGGnhw4hnUJGEYLMAwBMqxHwDBGgGEokGF9AoaxAgzDgAwbEDCME2AYDmTYkIBhvADDCCDDRgQMEwQYRgIZNiZgmCjAMAuQYRMChrcIMMwKZNiUgGF1AYbZgAybARnq9YjlPX+uRdTr8vS6Mr0uSq/r0etS9LoKvS5Av6+t35fV7yvq98X0+zr6fQk9r67nhfW8pp6X0/NKel5E39f/fl+qmr4v0Ne1+rpMX1doX9Tjuh6X9HmlddHM/MCORF2l1oc2B3/6sLznygPVvxRbJAOpGFu4fTcvnXB54Ic4dF8tBPbBaAGMsSXPySO2DwbDydMSHaPU6B4q0C9K7K2EPknQSvCTBAxcbw06sHErwSDS2u0OrDc6QTtwa4GTpzUwxjZBB6Y4edoEqANHIU/ItkIO3JbPgaFc2wUd2GhHMIi0d7sD6yEe7cDtBRy4PTDGDkEHpjh5OgSoA0cjT8jbhBz4Nj4HhnLtGHRgoyPBINLJ7Q6sN1NEO3AnAQfuBIyxc9CBKU6ezgHqwDHIE7KLkAN34XNgKNfbgw5s3E4wiHR1uwPrXtEO3FXAgbsCY7wj6MAUJ88dAerAscgTspuQA3fjc2Ao1+5BBza6EwwiPdzuwDcL3AP3EHDgHsAYk4IOTHHyJAWoA8chT8hkIQdO5nNgKNeUoAMbKQSDSKrbHbi4gAOnCjhwKjDGtKADU5w8aQHqwPHIEzJdyIHT+RwYyrVn0IGNngSDSC+3O3BpAQfuJeDAvYAx9g46MMXJ01sgxt8P9PfC9MEF+pfvKotKio1PiUmKUeEkx6VExSQYMXHRKenpyUasEZUaayRER6XGJUenxyUlRMVExacbyXEq6jQjPuqPvoDfCwP9ri0JseiBR9cB/bnfO4WuYO4UvILxDeroQRhpFH2FuPY1ubJe1bSKdH+M/ZADM2uhZhEUqn+wUF5jNkGhBgQL5TXOh7o/xoFS16R2r/6v/pr2x3eQpiK/l3IQLukYVnEOIrhhGkwizhSkOIfgko5lFecQAnEODcSRcxgu6ThWcQ4jEOfwQBw5R+CSjmcV5wgCcY4kEWciUpyjcEknsIpzFIE4R5OIMwEpzjG4pBNZxTmGQJxjA3HkvAuXdBKrOO8iEOe4QBTneFzSyaziHE8gzgkk4oxFivNuXNIprOK8m0CcE0nEGYMU5z24pFNZxXkPgTgnBeLIORmXdBqrOCcTiPPeQBw578Mlnc4qzvsIxDmFRJwGUpz3w5I2aFfy308gzgdIxOlFivNBnDgNVnE+SCDOhwJx5HwYJ84oVnE+TCDORwJRnFNx4oxmFedUAnE+yiHONOiqpMdw4qRdz/kYgTgfJxEndFXSEzhx0q7nfIJAnNMCceR8EidO2vWcTxKI86lAHDmfxomTdj3n0wTinE4iTujCj2dw4qRdz/kMgThnkIgTup7zWZw4addzPksgzpmBOHLOwomTdj3nLAJxPheI4pyNEyftes7ZBOKcQyJO6KqkuThx0q7nnEsgzudJxAldlfQCTpy06zlfIBDni4E4cr6EEyftes6XCMQ5LxBHzpdx4qRdz/kygThf8df+nd7MHUa1SJw4+wD3SIzJj+trRmGZYqBr0Ss/rq/TQvufZnq6UagWYbZaZDbOV4H72gL1ZyD5aQMo57nyQNcnEPcJnY/e1ZCxUAz7hC4IFopjn9CFwUJx7BO6KFgor/ERwRn1WrBQXuMEQaFeDxbKa3xCUKg3goXyGqcICrU4WCiv8TlBoZYEC+U1viQo1JvBQnmNMwSFeitYKK9xlqBQS4OF8hpfExTq7WChvMa3BIVaFiyUmkIiKNTyYKG8xvcEhVoRiBscrATvW8QozpUEizBWkYgzCinO1eB9ixjFuZpAnGtIlq+lI8W5FrxvEaM41xKIcx2JONOQ4lwP3reIUZzrCcS5IRBHzo3gfYsYxbmRQJybAlGcm8H7FjGKczOBOLeQiDMZKc6t4H2LGMW5lUCc2wJx36Lt4H2LGMW5nUCc7wTiBgc7wPsWMYpzB4E4dwbivkW7wPsWMYpzF4E4dwfiyLkHvG8Rozj3EIhzbyCK813wvkWM4nyXQJz7AnH3jf3gfYsYxbmfQJwHSMQZhxTnQfC+RYziPEggzkMk4oxGivMweN8iRnEeJhDnERJxQlclvQfet4hRnO8RiPNoII6c78OSjqJdz/k+gTg/CERxHsOJk3Y95zECcX7IIc5U6MKP4zhx0q7nPE4gzo9IRk7oN/h+jBMn7XrOjwnEeYJk5IR+m9pJnDhp13OeJBDnJyTihK5K+hQnTtr1nJ8SiPNUII6cn+HESbue8zMCcX4eiOL8AidO2vWcXxCI80sScUIXfpzGiZN2PedpAnGeIRFnElKcX+HESbue8ysCcZ4lEWc8UpzncOKkXc95jkCcX5OIE7oq6RucOGnXc35DIM5vA3Hk/A4nTtr1nN8RiPN8IIrzAk6ctOs5LxCI83sScUIXfvyAEyftes4fCMT5I4k4od9D+RNOnLTrOX8iEOfPJOKE7s95EZZ0NO16zosE4rxEIk7oqqRfcOKkXc/5C4E4fw3EkfMyTpy06zkvE4jzt0AUpyc3TJy06zlxDORiDMlNIc4U6MKPUJw4addzhhKIM4xEnNCdjcNx4qRdzxlOIM4IEnFC9+eMxImTdj1nJIE4s5CIE7oqKStOnLTrObMSiDNbII6c2XHipF3PmZ1AnDkCUZw5ceKkXc+Zk0CcuUjECV34kRsnTtr1nLkJxJmHRJzQnY3z4sRJu54zL4E485GIE7o/Z36cOGnXc+YnEGcBEnFCVyUVxImTdj1nQQJxFgrEkfM6nDhp13NeRyDOwoEoziI4cdKu5yxCIM7rScQJXfhxAyzpGNr1nDcQiLMoiTihOxvfiBMn7XrOGwnEeROHOJOh+3MWw4mTdj1nMQJxFicRJ3RVUgmcOGnXc5YgEGfJQBw5S+HESbuesxSBOEsHojhvxomTdj3nzQTiLEMiTujCj7I4cdKu5yxLIM5yJOKE7mxcHidO2vWc5QnEWYFEnND9OSvixEm7nrMigTgrkYgTuiqpMk6ctOs5KxOIs0ogjpxVceKkXc9ZlUCc1QJRnF6cOGnXc3oJxGmQiBO68CMKJ07a9ZxRBOKMJhEndGfjGJw4addzxhCIM5ZEnND9OeNw4qRdzxlHIM54EnFCVyUl4MRJu54zgUCciYE4ct4CSzqWdj3nLQTirB6I4qyBEyftes4aBOKsySHOJOjCj1o4cdKu56xFIM7aJCMndGfjOjhx0q7nrEMgzrokIyd0f856OHHSruesRyDO+iTihK5KaoATJ+16zgYE4mwYiCNnI5w4addzNiIQZ+NAFGcTnDhp13M2IRBnUxJxQhd+NMOJk3Y9ZzMCcTYnESd0Z+MWOHHSrudsQSDOliTihO7P2QonTtr1nK0IxHkriTihq5Ja48RJu56zNYE42wTiyNkWJ07a9ZxtCcTZLhDF2R4nTtr1nO0JxNmBRJzQhR+34cRJu57zNgJxdiQRJ3Rn4044cdKu5+xEIM7OUuKMBAdaMhdOnF1y4/qKyQ+8Fgb2tb8gkFdhGZGgBjBfnMgB7HbciWE45erN3GHMUbnOBear+yqtzrFwcE2QMRbHfYu0URo4nnR1uVZ0DSrlwta0n+ovDKyVSsD69gPmewfYJCXqWxlc3/4C9a0MrG9/YL7dCOpbBVzfAQL1rQKs7wBgvt0J6lsVXN+BAvWtCqzvQGC+PQjqWw1c38EC9a0GrO9gYL5JBPX1gus7VKC+XmB9hwLzTSaorwGu73CB+hrA+g4H5ptCUN8ocH1HCtQ3CljfkcB8UwnqGw2u72iB+kYD6zsamG8aQX1jwPUdK1DfGGB9xwLzTSeobyy4vuME6hsLrO84YL49CeobB67vBIH6xgHrOwGYby+C+saD6ztRoL7xwPpOBObbm6C+CeD6ThKobwKwvpOA+fYhqG8iuL73CtQ3EVjfe4H53klQ31vA9Z0iUN9bgPWdAsy3L0F9q4Pr+4BAfasD6/sAMN9+BPWtAa7vQwL1rQGs70PAfPsT1LcmuL6PCNS3JrC+jwDzHUBQ31rg+j4qUN9awPo+Csx3IEF9a4Pr+7hAfWsD6/s4MN9BBPWtA67vNIH61gHWdxow38EE9a0Lru9TAvWtC6zvU8B8hxDUtx64vtMF6lsPWN/pwHyHEtS3Pri+MwTqWx9Y3xnAfIcR1LcBuL4zBerbAFjfmcB8hxPUtyG4vs8J1LchsL7PAfMdQVDfRuD6zhGobyNgfecA8x1JUN/G4Po+L1DfxsD6Pg/MdxRBfZuA6/uiQH2bAOv7IjDf0QT1bQqu7zyB+jYF1nceMN8xBPVtBq7vKwL1bQas7yvAfMeC64ve5EHX41WBetwF3EdhRmFcX88Wlj3fIOdHTmx95+e6UjeZjXNcbvdzfBXMcYEAx/EEHOeDOS4U4DiBgOMCMMdFAhzvJuC4EMzxNQGOEwk4LgJzfF2A4z0EHF8Dc3xDgOMkAo6vgzkuFuA4mYDjG2COSwQ43kvAcTGY45sCHO8j4LgEzPEtAY5TCDi+Cea4VIDj/QQc3wJzfFuA4wMEHJeCOS4T4PggAce3wRyXC3B8iIDjMjDHFQIcHybguBzMcZUAx0cIOK4Ac1wjwHEqAceVYI7rBDg+SsBxFZjjBgGOjxFwXA3muEmA4+MEHNeAOW4R4PgEAce1YI7bBDhOI+C4DszxHQGOTxJwXA/muFOA41MEHDeAOe4W4Pg0AceNYI57BThOJ+C4CcxxnwDHZwg4bgZzPCDAcQYBxy1gjocEOD5LwHErmOMRAY4zCThuA3M8KsBxFgHH7WCOHwhwfI6A4ztgjh8KcJxNwHEHmONHAhznEHDcCeZ4QoDjXAKOu8AcPxHg+DwBx91gjqcEOL5AwHEPmOPnAhxfJOC4F8zxSwGOLxFwfBfM8YwAx3kEHPeBOZ4V4PgyAcf9YI5fC3B8hYDjATDHbwU4vkrA8SCY43kBjvMJOB4Cc/xegOMCAo6HwRx/FOC4kIDjETDHnwU4LiLg+B6Y4yUBjq8RcDwK5virAMfXCTi+D+b4mwDHNwg4fgDmGJIbz3ExAcdjYI5hAhyXEHD8EMwxQoDjmwQcj4M5ZhHg+BYBx4/AHLMJcFxKwPFjMMccAhzfJuB4AswxlwDHZQQcT4I55hHguJyA4ydgjvkEOK4g4PgpmGMBAY4rCTieAnMsJMBxFQHHz8AcCwtwXE3A8XMwx+sFOK4h4PgFmGNRAY5rCTh+CeZ4kwDHdQQcT4M5FhfguJ6A4xkwx5ICHDcQcPwKzLG0AMeNBBzPgjmWEeC4iYDjOTDHcgIcNxNw/BrMsYIAxy0EHL8Bc6wkwHErAcdvwRyrCHDcRsDxOzDHagIctxNwPA/maAhwfIeA4wUwx2gBjjsIOH4P5hgrwHEnAccfwBzjBTjuIuD4I5hjogDH3QQcfwJzrC7AcQ8Bx5/BHGsKcNxLwPEimGNtAY7vEnC8BOZYV4DjPgKOv4A51hfguJ+A469gjg0FOB4g4HgZzLGxAMeDBBx/A3NsKsDxEAFHTy4sx+YCHA8TcAwBc2wpwPEIAcdQMMdbBTi+R8AxDMyxjQDHowQcw8Ec2wlwfJ+AYwSYYwcBjh8QcIwEc+wowPEYAccsYI6dBTh+COYo8X3kXQTyPg7MO1z1kcWSu/VA84jH9eW1xvtRbsGAP8qN7/fj3DgxSOX9ce4/AYP6FYn1dhVn19xXDoLezB1G8Vy4Gp3AnbCGE8PMxpdg1hvNMAEY40mXD/a6xicFBvtPcmMHzTAzd91vCfVvuPm7CM+Vh5sNQDLOOJI4Yz0cYzO63+K5ZPPO7Dmb6PnjnEKPp2HAvhI9Mhdjn1rqDS/8SfCVb1ZLkfQRAY63WqTHUyYS1990daleNCuuv6PZ1AmaHdffDeqOZ1ZO7AByHHghmv7H8ZdBGdS34Xtg1dMpM/bPcpsng899T5lnifV3n5mO7PHIjMTHBa5OPr1eximzYOKMMuM0TgHvuD4DXs3H5Mf11RbY1/6CuL66FMb1hdCbdRBAnw/aoE4J3Tn7jnBwzJ/j9ByHrHU3XF9x6HFK4sLmc4Hx+Quhu8cvhL1qnMBsxCs5cVy/dPlshGY4XoDhq0CGpwkYThBgOB/I8AwBw7sFGC4AMvyKgOFEAYYLgQzPEjC8R4DhIiDDcwQMJwkwfA3I8GsChpMFGL4OZPgNAcN7BRi+AWT4LQHD+wQYLgYy/I6A4RQBhkuADM8TMLxfgOGbQIYXCBg+IMDwLSDD7wkYPijAcCmQ4Q8EDB8SYPg2kOGPBAwfFmC4DMjwJwKGjwgwXA5k+DMBw6kCDFcAGV4kYPioAMOVQIaXCBg+JsBwFZDhLwQMHxdguBrI8FcChk8IMFwDZHiZgOE0AYZrgQx/I2D4pADDdUCGnjzuZ/iUAMP1QIYhBAyfFmC4AcgwlIDhdAGGG4EMwwgYPiPAcBOQYTgBwxkCDDcDGUYQMHxWgOEWIMNIAoYzBRhuBTLMQsBwlgDDbUCGWQkYPifAcDuQYTYChrMFGL4DZJidgOEcAYY7gAxzEDCcK8BwJ5BhTgKGzwsw3AVkmIuA4QsCDHcDGeYmYPiiAMM9QIZ5CBi+JMBwL5BhXgKG8wQYvgtkmI+A4csCDPcBGeYnYPiKAMP9QIYFCBi+KsDwAJBhQQKG8wUYHgQyLETAcIEAw0NAhtcRMFwowPAwkGFhAoaLBBgeATIsQsDwNQGG7wEZXk/A8HUBhkeBDG8gYPiGAMP3gQyLEjBcLMDwAyDDGwkYLhFgeAzI8CYChm8KMPwQyLAYAcO3BBgeBzIsTsBwqQDDj4AMSxAwfFuA4cdAhiUJGC4TYHgCyLAUAcPlAgxPAhmWJmC4QoDhJ0CGNxMwXCnA8FMgwzIEDFcJMDwFZFiWgOFqAYafARmWI2C4RoDh50CG5QkYrhVg+AWQYQUChusEGH4JZFiRgOF6AYangQwrETDcIMDwDJBhZQKGGwUYfgVkWIWA4SYBhmeBDKsSMNwswPAckGE1AoZbBBh+DWToJWC4VYDhN0CGBgHDbQIMvwUyjCJguF2A4XdAhtEEDN8RYHgeyDCGgOEOAYYXgAxjCRjuFGD4PZBhHAHDXQIMfwAyjCdguFuA4Y9AhgkEDPcIMPwJyDCRgOFeAYY/AxneQsDwXQGGF4EMqxMw3CfA8BKQYQ0ChvsFGP4CZFiTgOEBAYa/AhnWImB4UIDhZSDD2gQMDwkw/A3IsA4Bw8MCDD25cAzrEjA8IsAwBMiwHgHD9wQYhgIZ1idgeFSAYRiQYQMChu8LMAwHMmxIwPADAYYRQIaNCBgeE2AYCWTYmIDhhwIMswAZNgEy1N/HXEG1HmZ/+nuJ9ffq6u+F1d9rqr+XU3+vpP5eRP29fvp76fT3qunvBdPfa6W/l0l/r5D+Xhz9vS76e0n092pcUk1/r4Hel1/vK6/3Rdf7eut9qfW+ynpfYL2vrd6XVe8rqvfF1Ps66n0J9b56el84va+Z3pdL7yul90XS+/rofWn0vip6XxC9r4Xel0HvK6A/F68/160/l6w/V6s/F6o/16g/l6c/V6Y/F6U/16M/l6I/V6E/F6DXtet12XpdsV4Xq9d16nWJel2dXhem1zXpdTl6XYleF6Hf19fvS+v3VfX7gvp9Lf2+jH5fQc+L63ldPS+p59X0vJCe19D35fq+8vf7ItX0dam+rtLXBdrX9LisxxV9Xui6+g6W7wdvCtRiqKlF+4HqX4otkoFUjM3QMcJvXFQfWqQoYeq+dNLoOK0gMxtjc56Tx5ASJsPJ0xwdo9ToHirQL0rsLYAQNb8wk6Put4RQ4Rm4tgw6sNGSYBBp5XYHjvfgHbiVgAO3AjrwrUEHpjh5bg1QB45CnpCthRy4NZ8DQ7m2CTqw0YZgEGkrPYggHFMHGQZKPDU2JsZI9qZaxe7N3PEXiJnNt13QfSlOnHYB6r7RSJdoL+S+7fncF8q1Q9B9jQ4Eg8htbndffUIlenDuax5GGLCvRGC+HcEFCQXXQw8SQNH8Pph1FJiPuA14RdQpeEVEMZh1CtArohikc3cWuiLqzHdFBOXaJXhFZHQhGERud/s7AlqUn4LfEbhdwIFvBzpw16ADU5w8XQPUgWORTnGHkAPfwefAUK7dgg5sdCMYRLq7fRDRy5G7CixAKQ5cjtyDYB6hO3geoYfAVUx34FVMUvAqhmIAQtbJE6460S3iylrBA4/34OFKxBlHEmcsSZw98nDE2RE8APqOZPMzGinq3xB00B8rZ0nw4B0wAdjXx8C1BNZbhmTzlkEPYFktDPQRAeZRJtLjqRaJy2N6Fo9nZRZcf0ezeTyXsuH6uyGnx1MjJ/aq9K7c+JMWUZP0P44Uj8ORyb4N3wOrNlPNASEtjylkn6D1EyG236UJ3hdfrSiZPVkuXy8z4kcKiuc/5hxl5mykAi/F04C3HkML4/oaDuwLoRGnExdthMi6pgPrKjEeaNPXZh0GZih1MZHZvnq6vB5aLz3z4MfnnkJX5OiLrl64OBNOF8TV5RyurwTg+JyA9l20nrXuegnoubfQexK9ha+97hCYpq0EnKbtk8fdetIMuwkwrAxkeCcBw+4CDKsAGfYlYNhDgGFVIMN+BAyTBBhWAzLsT8AwWYChF8hwAAHDFAGGBpDhQAKGqQIMo4AMBxEwTBNgGA1kOJiAYboAwxggwyEEDHsKMIwFMhxKwLCXAMM4IMNhBAx7CzCMBzIcTsCwjwDDBCDDEQQM7xRgmAhkOJKAYV8BhrcAGY4iYNhPgGF1IMPRBAz7CzCsAWQ4hoDhAAGGNYEMxxIwHCjAsBaQ4V0EDAcJMKwNZDiOgOFgAYZ1gAzHEzAcIsCwLpDhBAKGQwUY1gMyvJuA4TABhvWBDCcSMBwuwLABkOE9BAxHCDBsCGQ4iYDhSAGGjYAMJxMwHCXAsDGQ4b0EDEcLMGwCZHgfAcMxAgybAhlOIWA4VoBhMyDD+4EM9XrEip4/1yLqdXl6XZleF6XX9eh1KXpdhV4XoN/X1u/L6vcV9fti+n0d/b6EnlfX88J6XlPPy+l5JT0vou/r9X2pvq/S9wX6ulZfl+nrCu2LelzX45I+r7Qu7jc/vCJRV6n1oQ+AP9lX0XPlgepfii2SgVSMD7p9dyOdcE/gB0J0Xw8K7AvwIDDGh3hOHrF9ARhOnofQMUqN7qEC/aLE/rDQJwkeFvwkAQPXR4IObDxCMIhMdbsD601E0A48VeDkmQqM8dGgA1OcPI8GqANHIU/Ix4Qc+DE+B4ZyfTzowMbjBIPIE253YL09FtqBnxBw4CeAMU4LOjDFyTMtQB04GnlCPinkwE/yOTCU61NBBzaeIhhEnna7A+uNCtEO/LSAAz8NjHF60IEpTp7pAerAMcgT8hkhB36Gz4GhXGcEHdiYQTCIPOt2B9ZbL6Md+FkBB34WGOPMoANTnDwzA9SBY5En5CwhB57F58BQrs8FHdh4jmAQme12B04RuAeeLeDAs4Exzgk6MMXJMydAHTgOeULOFXLguXwODOX6fNCBjecJBpEX3O7APQQc+AUBB34BGOOLQQemOHleDFAHjkeekC8JOfBLfA4M5Tov6MDGPIJB5GW3O3CygAO/LODALwNjfCXowBQnzytud2DfyYMWO/KEfFXIgV81HZjVPVpFuj/G+cgTgLVQswgKtSBYKDVNTVCohcFCeY3zoe6PcZHA9cnvh92r/6u/pv3xvZGpyO8SfA2XdAyrOF8juDB9nUScKUhxvoFLOpZVnG8QiHNxII6cS3BJx7GKcwmBON8MxJHzLVzS8azifItAnEtJxJmIFOfbuKQTWMX5NoE4l5GIMwEpzuW4pBNZxbmcQJwrAnHkXIlLOolVnCsJxLkqEMW5Gpd0Mqs4VxOIcw2JOGOR4lyLSzqFVZxrCcS5jkScMUhxrsclncoqzvUE4twQiCPnRlzSaazi3Eggzk2BOHJuxiWdzirOzQTi3EIiTgMpzq2wpA3aFdNbCcS5jUScXqQ4t+PEabCKczuBON8JxJFzB06cUazi3EEgzp2BKM5dOHFGs4pzF4E4d3OIMw26KmkPTpy06zn3EIhzL4k4oauS3sWJk3Y957sE4twXiCPnfpw4addz7icQ54FAHDkP4sRJu57zIIE4D5GIE7rw4zBOnLTrOQ8TiPMIiTih6znfw4mTdj3newTiPBqII+f7OHHSrud8n0CcHwSiOI/hxEm7nvMYgTg/JBEndFXScZw4addzHicQ50ck4oSuSvoYJ07a9ZwfE4jzRCCOnCdx4qRdz3mSQJyfBOLI+SlOnLTrOT8lEOcp9KZWFTx8hWLYz++zYKE49vP7PFgojv38vggWimM/vy+DhVL33wRn1OlgodS9KEGhzgQLpe7LCAr1VbBQ6h6FoFBng4VSl74EhToXLJS6oiIo1NfBQimjJijUN8FCqfGfoFDfBgulhhWCQn0XLJRSK0GhzgcLpSAQFOpCsFBe43uCQn0fiB9E/gG8vwijOH8geLP0RxJxRiHF+RN4fxFGcf5EIM6fSZaZpCPFeRG8vwijOC8SiPMSiTjTkOL8Bby/CKM4fyEQ56+BOHJeBu8vwijOywTi/C0QxenJCxNnLKs4cQzkYgzJyyHOZKQ4Q3HijGMVZyiBOMNIxAndXyQcJ854VnGGE4gzgkSc0A8iR+LEmcAqzkgCcWYhESd0f5GsOHEmsoozK4E4swXiyJkdJ84kVnFmJxBnjkAUZ06cOJNZxZmTQJy5SMQJ/ZR8bpw4U1jFmZtAnHlIxBmHFGdenDhTWcWZl0Cc+UjEGY0UZ36cONNYxZmfQJwFSMQJXZVUECfOdFZxFiQQZ6FAHDmvgyUdRbue8zoCcRYORHEWwYmTdj1nEQJxXs8hzlTowo8bcOKkXc95A4E4i5KMnNBv2rwRJ07a9Zw3EojzJpKRE/qtR8Vw4qRdz1mMQJzFScQJXZVUAidO2vWcJQjEWTIQR85SOHHSrucsRSDO0oEozptx4qRdz3kzgTjLkIgTuvCjLE6ctOs5yxKIsxyJOJOQ4iyPEyftes7yBOKsQCLOeKQ4K+LESbuesyKBOCuRiBO6KqkyTpy06zkrE4izSiCOnFVx4qRdz1mVQJzVAlGcXpw4addzegnEaZCIE7rwIwonTtr1nFEE4owmESf0++JicOKkXc8ZQyDOWBJxQvfnjIMlHU27njOOQJzxJOKErkpKwImTdj1nAoE4EwNx5LwFJ07a9Zy3EIizeiCKswZOnLTrOWsQiLMmhzhToAs/auHESbuesxaBOGuTiBO6s3EdnDhp13PWIRBnXRJxQvfnrIcTJ+16znoE4qxPIk7oqqQGOHHSrudsQCDOhoE4cjbCiZN2PWcjAnE2DkRxNsGJk3Y9ZxMCcTYlESd04UcznDhp13M2IxBncxJxQnc2boETJ+16zhYE4mxJIk7o/pytcOKkXc/ZikCct5KIE7oqqTVOnLTrOVsTiLNNII6cbXHipF3P2ZZAnO0CUZztceKkXc/ZnkCcHUjECV34cRss6Rja9Zy3EYizI4k4oTsbd8KJk3Y9ZycCcXbmEGcydH/OLjhx0q7n7EIgzttJxAldldQVJ07a9ZxdCcR5RyCOnN1w4qRdz9mNQJzdA1GcPXDipF3P2YNAnEkk4oQu/EjGiZN2PWcygThTSMQJ3dk4FSdO2vWcqQTiTCMRJ3R/znScOGnXc6YTiLMniTihq5J64cRJu56zF4E4ewfiyNkHJ07a9Zx9CMR5ZyCKsy9OnLTrOfsSiLMfiTihCz/648RJu56zP4E4B5CIE7qz8UCcOGnXcw4kEOcgEnFC9+ccjBMn7XrOwQTiHEIiTuiqpKE4cdKu5xxKIM5hgThyDoclHUu7nnM4gThHBKI4R+LESbuecySBOEdxiDMJuvBjNE6ctOs5RxOIcwzJyAnd2XgsTpy06znHEojzLpKRE7o/5zicOGnXc44jEOd4EnFCVyVNwImTdj3nBAJx3h2II+dEnDhp13NOJBDnPYEozkk4cdKu55xEIM7JJOKELvy4FydO2vWc9xKI8z4ScUJ3Np6CEyftes4pBOK8n0Sc0P05H8CJk3Y95wME4nyQRJzQVUkP4cRJu57zIQJxPhyII+cjOHHSrud8hECcUwNRnI/ixEm7nvNRAnE+RiJO6MKPx3HipF3P+TiBOJ8gESd0Z+NpOHHSruecRiDOJ90uTp+gkOJ8Cpe04ZSrN3OHcULlehKYr+4rOY/HEw6uCTLGHnlw/JLz4OJ62uVa0TXokwdb0/mqvzCwVvoA6zsfmO908AAoUd87wfVdIFDfO4H1XQDM9xmC+vYF13ehQH37Auu7EJjvDIL69gPXd5FAffsB67sImO+zBPXtD67v6wL17Q+s7+vAfGcS1HcAuL6LBeo7AFjfxcB8ZxHUdyC4vm8K1HcgsL5vAvN9jqC+g8D1XSpQ30HA+i4F5juboL6DwfVdJlDfwcD6LgPmO4egvkPA9V0hUN8hwPquAOY7l6C+Q8H1XSVQ36HA+q4C5vs8QX2Hgeu7RqC+w4D1XQPM9wWC+g4H13edQH2HA+u7DpjviwT1HQGu7waB+o4A1ncDMN+XCOo7ElzfTQL1HQms7yZgvvMI6jsKXN8tAvUdBazvFmC+LxPUdzS4vtsE6jsaWN9twHxfIajvGHB93xGo7xhgfd8B5vsqQX3Hguu7U6C+Y4H13QnMdz5Bfe8C13e3QH3vAtZ3NzDfBQT1HQeu716B+o4D1ncvMN+FBPUdD67vPoH6jgfWdx8w30UE9Z0Aru8BgfpOANb3ADDf1wjqeze4vocE6ns3sL6HgPm+TlDfieD6HhGo70RgfY8A832DoL73gOt7VKC+9wDrexSY72KC+k4C1/cDgfpOAtb3A2C+SwjqOxlc3w8F6jsZWN8Pgfm+SVDfe8H1/UigvvcC6/sRMN+3COp7H7i+JwTqex+wvieA+S4lqO8UcH0/EajvFGB9PwHm+zZBfe8H1/eUQH3vB9b3FDDfZcL1RdTjy9xYvXyW58qNBjIb53ICjqfBHD8X4LiCgOMZMMcvBDiuJOD4FZjjlwIcVxFwPAvmeFqA42oCjufAHM8IcFxDwPFrMMevBDiuJeD4DZjjWQGO6wg4fgvmeE6A43oCjt+BOX4twHEDAcfzYI7fCHDcSMDxApjjtwIcNxFw/B7M8TsBjpsJOP4A5nhegOMWAo4/gjleEOC4lYDjT2CO3wtw3EbA8Wcwxx8FOG4n4HgRzPFnAY7vEHC8BOZ4SYDjDgKOv4A5/irAcScBx1/BHH8T4LiLgONlMMeQvHiOuwk4/gbmGCbAcQ8BR08eLMcIAY57CTiGgDlmEeD4LgHHUDDHbAIc9xFwDANzzCHAcT8Bx3Awx1wCHA8QcIwAc8wjwPEgAcdIMMd8AhwPEXDMAuZYQIDjYQKOWcEcCwlwPELAMRuYY2EBju8RcMwO5ni9AMejBBxzgDkWFeD4PgHHnGCONwlw/ICAYy4wx+ICHI8RcMwN5lhSgOOHBBzzgDmWFuB4nIBjXjDHMgIcPyLgmA/MsZwAx48JOOYHc6wgwPEEAccCYI6VBDieJOBYEMyxigDHTwg4FgJzrCbA8VMCjteBORoCHE8RcCwM5hgtwPEzAo5FwBxjBTh+TsDxejDHeAGOXxBwvAHMMVGA45cEHIuCOVYX4HiagOONYI41BTieIeB4E5hjbQGOXxFwLAbmWFeA41kCjsXBHOsLcDxHwLEEmGNDAY5fE3AsCebYWIDjNwQcS4E5NhXg+C0Bx9Jgjs0FOH5HwPFmMMeWAhzPE3AsA+Z4qwDHCwQcy4I5thHg+D0Bx3Jgju0EOP5AwLE8mGMHAY4/EnCsAObYUYDjTwQcK4I5dhbg+DMBx0pgjrcLcLxIwLEymOMdAhwvEXCsAubYXYDjLwQcq4I5Jglw/JWAYzUwxxQBjpcJOHrBHNMEOP5GwNEAc+wpwNGTz/0co8AcewtwDCHgGA3meKcAx1ACjjFgjv0EOIYRcIwFcxwgwDGcgGMcmOMgAY4RBBzjwRyHCHCMJOCYAOY4TIBjFgKOiWCOIwQ4ZiXgeAuY4ygBjtkIOFYHcxwjwDE7AccaYI53CXDMQcCxJpjjeAGOOQk41gJzvFuAYy4CjrXBHO8R4JibgGMdMMfJAhzzEHCsC+Z4nwDHvAQc64E53i/AMR8Bx/pgjg8KcMxPwLEBmOPDAhwLEHBsCOY4VYBjQQKOjcAcHxPgWIiAY2MwxycEOF5HwLEJmOOTAhwLgzn6DnScRWBxRonGef1/jzPK/gsdWwHVwi2xag6Xzce3eP583Cryz8fXm6/x/X83qJ+Lqnajajfl+2t/1ty9mTuMp5Q+n86L/477HsDvey+G07shwbCx6kPHiNZlceB5rmMLM3PX/ZbwyJxLPj2h+02/UWbMCwfH2QPoH1bdZzauEsBzCF2LQBzTSgp5OPqaCMmviYcj5xBgzk1Jcg4F5tyMJOcwYM7N/ZSzN3OH0QLI7+5Q/9yHeDN3GC1JatMKWJtZWTnOwUZAfrd6OPTYmiTONuA40efLOdXhd6E4Leq+LoTi42wLPF/OhXKMZe2AOU8m8Zn2Ho44O5DEeRtJnB1J4uxEEmdnkji7kMR5O0mcXUnivIMkzm4kcXYnibMHSZxJJHEmk8SZQhJnKkmcaSRxppPE2ZMkzl4kcfYmibMPSZx3ksTZlyTOfiRx9ieJcwBJnANJ4hxEEudgkjiHkMQ5lCTOYSRxDieJcwRJnCNJ4hxFEudokjjHkMQ5liTOu0jiHEcS53iSOCeQxHk3SZwTSeK8hyTOSSRxTiaJ816SOO8jiXMKSZz3k8T5AEmcD5LE+RBJnA+TxPkISZxTSeJ8lCTOx0jifJwkzidI4pxGEueTJHE+RRLn0yRxTieJ8xmSOGeQxPksSZwzSeKcRRLncyRxziaJcw5JnHNJ4nyeJM4XSOJ8kSTOl0jinEcS58skcb5CEuerJHHOJ4lzAUmcC0niXEQS52skcb5OEucbJHEuJolzCUmcb5LE+RZJnEtJ4nybJM5lJHEuJ4lzBUmcK0niXEUS52qSONeQxLmWJM51JHGuJ4lzA0mcG0ni3EQS52aSOLeQxLmVJM5tJHFuJ4nzHZI4d5DEuZMkzl0kce4miXMPSZx7SeJ8lyTOfSRx7ieJ8wBJnAdJ4jxEEudhkjiPkMT5HkmcR0nifJ8kzg9I4jxGEueHJHEeJ4nzI5I4PyaJ8wRJnCdJ4vyEJM5PSeI8RRLnZyRxfk4S5xckcX5JEudpkjjPkMT5FUmcZ0niPEcS59ckcX5DEue3JHF+RxLneZI4L5DE+T1JnD+QxPkjSZw/kcT5M0mcF0nivEQS5y8kcf5KEudlkjh/I4lTd8gQZwg4Tnt8mf0+y8aqjxvy4fMOJci7pEDeYSS6DCeJM4IkzkiSOLOQxJmVJM5sJHFmJ4kzB0mcOUnizEUSZ26SOPOQxJmXJM58JHHmJ4mzAEmcBUniLEQS53UkcRYmibMISZzXk8R5A0mcRUnivJEkzptI4ixGEmdxkjhLkMRZkiTOUiRxliaJ82aSOMuQxFmWJM5yJHGWJ4mzAkmcFUnirEQSZ2WSOKuQxFmVJM5qJHF6SeI0XP4++VN5PZ7pqoWC844KwcXYJ4/7GT4jwDAayPBOAoYzBBjGABn2JWD4rADDWCDDfgQMZwowjAMy7E/AcJYAw3ggwwEEDJ8TYJgAZDiQgOFsAYaJQIaDCBjOEWB4C5DhYAKGcwUYVgcyHELA8HkBhjWADIcSMHxBgGFNIMNhBAxfFGBYC8hwOAHDlwQY1gYyHEHAcJ4AwzpAhiMJGL4swLAukOEoAoavCDCsB2Q4moDhqwIM6wMZjiFgOF+AYQMgw7EEDBcIMGwIZHgXAcOFAgwbARmOI2C4SIBhYyDD8QQMXxNg2ATIcAIBw9cFGDYFMrybgOEbAgybARlOJGC4WIBhcyDDewgYLhFg2ALIcBIBwzcFGLYEMpxMwPAtAYatgAzvJWC4VIDhrUCG9xEwfFuAYWsgwykEDJcJMGwDZHg/AcPlAgzbAhl+mdv9DFcIMGwHZHiagOFKAYbtgQzPEDBcJcCwA5DhVwQMVwswvA3I8CwBwzUCDDsCGZ4jYLhWgGEnIMOvCRiuE2DYGcjwGwKG6wUYdgEy/JaA4QYBhrcDGX5HwHCjAMOuQIbnCRhuEmB4B5DhBQKGmwUYdgMy/J6A4RYBht2BDH8gYLhVgGEPIMMfCRhuE2CYBGT4EwHD7QIMk4EMfyZg+I4AwxQgw4sEDHcIMEwFMrxEwHCnAMM0IMNfCBjuEmCYDmT4KwHD3QIMewIZXiZguEeAYS8gw98IGO4VYNgbyNBD8P7yuwIM+wAZhhAw3CfA8E4gw1AChvsFGPYFMgwjYHhAgGE/IMNwAoYHBRj2BzKMIGB4SIDhACDDSAKGhwUYDgQyzELA8IgAw0FAhlkJGL4nwHAwkGE2AoZHBRgOATLMTsDwfQGGQ4EMcxAw/ECA4TAgw5wEDI8JMBwOZJiLgOGHAgxHABnmJmB4XIDhSCDDPAQMPxJgOArIMC8Bw48FGI4GMsxHwPCEAMMxQIb5CRieFGA4FsiwAAHDTwQY3gVkWJCA4acCDMcBGRYiYHhKgOF4IMPrCBh+JsBwApBhYQKGnwswvBvIsAgBwy8EGE4EMryegOGXAgzvATK8gYDhaQGGk4AMixIwPCPAcDKQ4Y0EDL8SYHgvkOFNBAzPCjC8D8iwGAHDcwIMpwAZFidg+LUAw/uBDEsQMPxGgOEDQIYlCRh+K8DwQSDDUgQMvxNg+BCQYWkChucFGD4MZHgzAcMLAgwfATIsQ8DwewGGU4EMyxIw/EGA4aNAhuUIGP4owPAxIMPyBAx/EmD4OJBhBQKGPwswfALIsCIBw4sCDKcBGVYiYHhJgOGTQIaVCRj+IsDwKSDDKgQMfxVg+DSQYVUChpcFGE4HMqxGwPA3AYbPABl6CRh68uEZzgAyNAgYhggwfBbIMIqAYagAw5lAhtEEDMMEGM4CMowhYBguwPA5IMNYAoYRAgxnAxnGETCMFGA4B8gwnoBhFgGGc4EMEwgYZhVg+DyQYSIBw2wCDF8AMryFgGF2AYYvAhlWJ2CYQ4DhS0CGNQgY5hRgOA/IsCYBw1wCDF8GMqxFwDC3AMNXgAxrEzDMI8DwVSDDOgQM8wownA9kWJeAYT4BhguADOsRMMwvwHAhkGF9AoYFBBguAjJsQMCwoADD14AMGxIwLCTA8HUgw0YEDK8TYPgGkGFjAoaFBRguBjJsAmboO0LAOS8J4YjzTZI43yKJcylJnG+TxLmMJM7lJHGuIIlzJUmcq0jiXC0Up/1aIdOfFQLmvCbE3ddbjVUfJdT1Vhi41muB11s9cNdbRvqNHOfKOpJzej1JnBtI4txIEucmkjg3k8S5hSTOrSRxbiOJcztJnO+QxLmDJM6dJHHuIolzN0mce0ji3EsS57skce4jiXM/SZwHSOI8SBLnIZI4D5PEeYQkzvdI4jxKEuf7JHF+QBLnMZI4PySJ8zhJnB+RxPkxSZwnSOI8SRLnJyRxfkoS5ymSOD8jifNzkji/IInzS5I4T5PEeYYkzq9I4jxLEuc5kji/JonzG5I4vyWJ8zuSOM+TxHmBJM7vSeL8gSTOH0ni/Ikkzp9J4rxIEuclkjh/IYnzV5I4L5PE+RtJnJ5QjjhDSOIMJYkzjCTOcJI4I0jijCSJMwtJnFlJ4sxGEmd2kjhzkMSZkyTOXCRx5iaJMw9JnHlJ4swnFGeoLc7MftYuHJhzfpKcI4A5FyDJORKYc0GSnLMAcy5EknNWYM7XkeScDZhzYZKcswNzLkKScw5gzteT5JwTmPMNJDnnAuZclCTn3MCcbyTJOQ8w55tIcs4LzLkYSc75gDkXJ8k5PzDnEiQ5FwDmXJIk54LAnEuR5FwImHNpkpyvA+Z8M0nOhYE5lyHJuQgw57IkOV8PzLkcSc43AHMuT5JzUWDOFUhyvhGYc0WSnG8C5lyJJOdiwJwrk+RcHJhzFZKcSwBzrkqSc0lgztVIci4FzNlLknNpYM4GSc43A3OOAuas98fV7Yy5MKCJak1Va6Zac9VaqNZStVaq3apaa9XaqNZWtXaqtVetg2q3qdZRtU6qdVati2q3q9ZVtTtU66Zad9V6qJakWrJqKaqlqpamWrpqPVXrpVpv1fqodqdqfVXrp1p/1QaoNlC1QaoNVm2IakNVG6bacNVGqDZStVGqjVZtjGpjVbtLtXGqjVdtgmp3qzZRtXtUm6TaZNXuVe0+1aaodr9qD6j2oGoPqfawao+oNlW1R1V7TLXHVXtCtWmqPanaU6o9rdp01Z5RbYZqz6o2U7VZqj2n2mzV5qg2V7XnVXtBtRdVe0m1eaq9rNorqr2q2nzVFqi2ULVFqr2m2uuqvaHaYtWWqPamam+ptlS1t1Vbptpy1VaotlK1VaqtVm2NamtVW6faetU2qLZRtU2qbVZti2pbVdum2nbV3lFth2o7Vdul2m7V9qi2V7V3Vdun2n7VDqh2ULVDqh1W7Yhq76l2VLX3VftAtWOqfajacdU+Uu1j1U6odlK1T1T7VLVTqn2m2ueqfaHal6qdVu2Mal+pdla1c6p9rdo3qn2r2neqnVftgmrfq/aDaj+q9pNqP6t2UbVLqv2i2q+qXVbtN9X0ApgQ1UJVC1MtXLUI1SJVy6JaVtWyqZZdtRyq5VQtl2q5VcujWl7V8qmWX7UCqhVUrZBq16lWWLUiql2v2g2qFVXtRtVuUq2YasVVK6FaSdVKqVZatZtVK6NaWdXKqVZetQqqVVStkmqVVauiWlXVqqnmVc1QLUq1aNViVItVLU61eNUSVEtU7RbVqqtWQ7WaqtVSrbZee69aXdXqqVZftQaqNVStkWqNVWuiWlPVmqnWXLUWqrVUrZVqt6rWWrU2qrVVrZ1q7VXroNptqnVUrZNqnVXrotrtqnVV7Q7VuqnWXbUeqiWplqxaimqpqqWplq5aT9V6qdZbtT6q3alaX9X6qdZftQGqDVRtkGqDVRui2lDVhqk2XLURqo1UbZRqo1Ubo9pY1e5SbZxq41WboNrdqk1U7R7VJqk2WbV7VbtPtSmq3a/aA6o9qNpDqj2s2iOqTVXtUdUeU+1x1Z5QbZpqT6r2lGpPqzZdtWdUm6Has6rNVE1/573+znb9neNzVNPf+ay/s1h/567+zlj9naf6Ozv1d07q70zU3/mnv7NOf+ea/s4w/Z1X+jub9HcO6e/M0d/5or8DRX+/iP7uDv29GPo7J/T3OejvStDfQ6D3+Nf75+u96fVe7Xrfcr339nrV9J7Rej9mvdex3kdY79Gr97/Ve8vqfVv1nqh6v1G9l6feJ1PvQan3d9R7J+p9CfWef3o/Pb1Xnd4HTu+xpvcv03uD6X239J5Wer8ovReT3udI7yGk9+fRe998rJres0Xvh6L3GtH7eOg9MvT+E3pvB71vgt6TQH/eX3uS/py6/gy4/ny1/uyy/lyw/syt/jyr/qyo/hym/oyj/vyg/mye/tyb/kyZ/ryW/iyU/pyR/gyP/nyM/uyJNnb9mQn9eQS91l+vo9dr1PX6b722Wq9b1muC9XpbvZZVrxPVazD1+ka9dlCvy9Nr3vQaML0mSq8R0mtm9BoSvaZCrzHQ77nr96D1e7L6PUr9np1+D0u/p6Pf49Bz/noOXM8J6zlSPWeo59D0nJKeY9FzDvoeXN+T6ns0fc+ir+H1Na2+xtPXPPoaIPSP4cyj17bpo4nnz8NM9Xdv18/rtWB6bZReK6TXzui1JHpthV5roN971+9F6/dm9XuV+r07/V6Wfm9Hv9eh5/71XLieG9ZzpXruUM+l6bklPdei5x70vbi+N9X3aiVUK6laKdX0tZ6+9tHfPVBWtXKqlVetgmoVVaukWmXVqqhWVbVqqukLMUO1KNWiVYtRLVa1ONXiVUtQLVG1W1SrrloN1WqqVku12p4/ro3qqlZPtfqqNVCtoWqNVGvsufLoY3nc2vy30Kd1rx+04+WG1tdNMv/9uH22l5dcbt/d+txk898f82eteaTL/MLW557IoM+KEX/8u3Pa3q2vTElKtT4XH3H1/69WBs/dlsFzXc3n3j95sO3AAaNvtT7XPYNY+mXQ55AMnhuVwXMTMnju3gyeeySD557OIL8ZGeT3agZ9vp7Bc0szeG5VBs9tyOC5bRk8tzuD5w5m8NzhDJ7rkeXqz/U0n3Pi2cd8zonnvgz6PJLBcx9m8NynGTx3OoPnvsvguV8yyO+3DPIrm/XqfVbO4LmoDJ5LyOC5Whk81yCD55pl8FybDJ5rl8Fzu7Nd/bmD5nNOPI+YzznxrJU9g/wyeK5ZBs+1yeC5jhk81z2D53pnv3p+/bJfPb9pGfQ5I4Pn5mTw3LwMnluYwXNLMnhueQbPrcvguQ0ZPFc959Wfq2c+58SzkfmcE89FGfT5ZgbPrcjgufUZPLc1g+f2ZPDc0QzyO5ZBfmG5rt5ntgyey5PBc4UyeK5oBs+VzOC5chk8VzWD57wZPLcg99WfW2I+58RzqfmcE88b81y9z1IZPFc+g+eqZfBcbAbPNchz9Rwa57l6Dv0z6HNoBs+NzuC5CRk8d28Gzz2UwXOPZ/Dc9Ayey5nP+TlzaPl93kIfpo38b45W/1rf59Qxf/Zm7jCyWfpF95/gjUnO5vnrAY4/Opvnz/s/KT6+PgX695qXXZ76E/7s356LPnKZP4dYWPr+H335kt/yOn00sPQXYnuuocPf8j3XaILz39ZHY8tz4bbnmliei7A919TyXKTtuWaW53wsfMzNyzK0JmN8/WcT6F8d8QUc4vf9Lf27iiF/zdNXAw8uBq+TbiX6D5dh6PXpPcLCJsSmj0iZv50YYvt7HgeO1r+f3RYregwKsf09Xzx2PtZz2Xo+Wf/fvA7PWXOzPmf9O1kc/o5TX6HBvv5f9OU7r/N4rtRIhO3vhDn8nbAM/o79PNFHLof/zz/nu5HwX893oWuCDM93J64+Pllk+MT/Ez3Zvd3uf9baWf0wwtKX9fVZLDlaX2997Pv/rb+rYf6b16FP+/mR1XNlPtbf+V6vY4+z5Wb17JCr/Ovr1/473/+b3SEuf+ko1CGeXA6vz2xuQh5tZKTJyAxyywLIzWm89I1pvvEyq8Nz/1Z3TuOl73WS18jqSPTxst+/+f6W/QhzeI0vNv2v1/yfcjm8zuOXnIx4p+v+EFj/f14TZ5fp/3/3ojlE+Px5TuX0/LWuVxsvfK/P9S9fn/tfvj6Pw+sjM3h93n/Zf75/+fr8//L1Bf7l6wv+y9cXcni903WC75y+zvKc/RqrsOX31+Iay/f3s9tildJ6YQd21zmw0+eEb1zqmTa01YChaUOscVv7KuyQlzVv62usWrW/zmmsymnrx+kctP4+91V+n+cqv897ld/nu8rv81/l9wWu8vuCnisP65jm+znc9nN2289Zbf36zgEnrvYYnDhL/uzx499CxGodP+yPQ2y/z0jbIbb/3+PJ+BzzvT6j+x6rNnzXWtb/P9L2/1mvP+3X2U59Z3St7MQlo5gzytHpGtAaaw5bjta/a9e+7/+z3kuFO+QtPFce5XT95vHgr3+E5m2jna7fgP3H+frPKdN/rK//XDL9x0TY9DbM/Ff//Jzlb9p955+cD07XeLktr/G9Po/nynMlzz/oK6O/7XS9aO0zm+1vW+PKa/v/8lqes74u7Cp95/2bvPPY+sgo5oxydLrGtcaay5aj9e/m+wd9ZfS3na6XrX3mtP1ta1z5/0FfGf1tp2tva5/ZbX/bGpfv/83l8Ld9Y1s222vB59w/fi/C9/ezO+Qocd2cEVd92O85CjrEmtfhObu3Od0LFXT4O0595QH2lRfYVz5gX2HAviKBfYUA+8pte8467+bTnNWD8jjEkMX23D95P8M65v7b9zNCbM9Z8w5x6Mv3+4ze49OPM3pfxvf/Cr8/muCL1cfUet2ZwyGeCNvrXzX/1ed6dMjf558Rr4zmf63x+HhZWdrXG8i8f/InrxwOvEId4omwvf6NDHg55Z8RrxwOr3d6D9HpOiuHC3hl+we8lvmRl/3aMDQDXkL3LRnyyuUQq53X2gx4ZQPwsuZtv87MkgEvoXnu//HK5cArp0M8EbbXb8mAl1P+GfFymju35m2/NnZiKXxfmSGv7A6x2nntyoCX03sN/5aXNW/79XyODHgJ3efHC9+H/68euS28nephrZf19QfNf53q4cQ3o3o43edb87bXw1or3/+bzfZ3fI/rQHjFpci+LxcT51RvYPzp2Wy8wP3/bz1kHpn+E3395xXpP/5/8eeTif9/82r5Zfo3nOYQgP2n+fovKNP//8a7QiL9R3mv4fuWsSG2v+fxcL1v6WNXxCHWvA7P2cfIIg5/p4jD33HqKz+wrzzAvkKAfeUD9pUb2FchYF95gX3lcmmOBYF9ITWBZI/khTy3kXEVAPaF1Cqyjj59+a7rfX5UyhzYnK6ngZ4Y5/MU+5oM69/OJfS3Q2x/z+Nx9mPf38/lEI8v7uwOz2Xmu7MSE9PSYqPSkwxvbHRcdFpMiK1/X6z23/2Teyonb3e6bgeyjvHFGDbhz/5zW7jqI9zyXC7bcxGW53wx6nvOOJtOcwvF/0/4W/9+Xo+zHnyP/00t83v+qjXr+Wj/rEOI58rrNac1Lfb12fpxDttz1niz2J6zzrXltD1nPXcibM9Z58x98085LI/DJ/z5PKp+8Qle35Lh/+nPN89hP8Itz1tfX83swFoD37+ZOc/T45OM9Oik9KTYpNTUmJSk/Lb+9RFq4WT9zF9OC7cho/qn/L6Q0PM3Rw6BJNISElO9ielpSYZhRKV60/4uCd/vs0z483lfMcIsv/Od9L6TIqv19bbnslmeC5/w17+f3fw53PJ3rH354oiwvb6O2YFvwIm0/D++/z+vw9+PtP39v8Tt8DvrCWrvK8zhd77X65PX966+5lrS91qHfpE3jtaJY3T/CeYkmPUAxx/8oLfnj4HEbrINLP2F2J5r6PC3JPO0frha6IPBUQUc4vf9Lc2nqPk4zOF19rHT6U1Yu8E49WHtx87VWrc6/y1nw/4Le54Z5ZbRogF73k6LIDwOvwvxONfU4/A3wq7y/zr1G5pBHn/3//7dRZMvHoYLlRLmz9f6QqWy+ZjbixJigl6U8YHedCTE1ofHk/Gbh9weFON1ujG2jkX6CJ/w179tfS7C8pyTd0nqy8pHRl8x3gKeq2tK51nWwsOumxAbA6EYjRDb3/N4nCeSfL/z14e1w2zx2Pn4HusbSd/ERc+0oXWHDe3VsffQ/mlDrvhYmq/HOpbfW5+3HvbX2F9nf73T9AHjXWMZ82c33zUWMx8zXNFUMn++1lc0N5mPye+uE/11RSO0ZDhWeMmo4xWNNRff8z4NN5jwJ8sGE/4ak+81jSyvaXSV1zS2vKax5TX6yOjqycn5Gties55vDW3PWT8e28j2nPVOzheTdl3rx1n0Yd2yze66QlceCcJXtsbfXXn4lj5o97zefJzWf9CwtGFprYcl9+2d0mhY/5ShvQf0r5/Ut6/dBK2Csh72Pcrs/5/98uZqt86+nyMc+r3a/2//3dXEZ42fwUBuNH++1gaSbD4mN5CkoIFkfAQN5O8NpKAlLn04GYjTnp9+uu1PuNZTz7U8f+XotI+WsI6jQ2x/z+Nxvq31/X237dOljdl3oZKiPLj14N7Dk4am+WzZmoK121CHFO027XuNG+3a6SOL9o9j2ktq/519yZD9/9eH05AScpV/fX/H8zd/xylm5DZ50rOheT1Xv2bM6GOWIZ4r6xvm8LuM6vK/e36P6NAV6zS0+45cnr/Xy9W2GbUfTlq3DpENLP3aX2ePx4m507tLdl2Eea5k6fQxXKdh3Pf7bFf5O3XMn72ZO+KcLMKev5W5vR5X29bSfjjVw5fTv61HRkuLrOe0/d0D1nfl6ps/u2H5kO/Swmk8sntIRlv/CNl8lN2Pr7YV0dU+Et7c/Ffn2tWW2z/dBtceg/X11rztH6F3+ki4SzlneDnlxNn3et94EXmV19s/Su17fQfzX/2z7zvgnHw/zPZcqEPfeTL4/0Ku8pz1dx7PlV7qVJ+MljS6YSUd+u/HxCbFpyTFG0ZijJEWY8T+3d9PNx9zT2nEpvhrSkPmutNIlP4KBacpDadrnjDb6+z/j/X/a2B5TYOrvKah5TUNr/Kaq02NWF9ztakR62uaWF7T5CqvaWp5TdOrvKaZ5TXNrvKa5pbXNL/Ka1pYXtPiKq9paXlNy6u8ppXlNa2u8ppbLa+59SqvaW15TeurvKaN5TVtrvKatpbXtL3Ka9pZXtPuKq9pb3lN+6u8poPlNR2u8prbLK+57Sqv6Wh5TcervKaT5TWdrvKazpbXdL7Ka7pYXtPF9hrJj+Ooaa9o2XHESHCaTvTlInufZPzj7c/+936+R3LM/vP6K6P7SX3YVwNZVwqF2J4Ln3BlHn+3UugWy+uctKUP2ffyYpOF/cu4drr7437G+vc8Hn7dZbRC7b/q7mrvszY0H8uOfbEpwisx/7eSzRq/fb4lywTP/w4fAzetbfLN8bh5bVNN87FvvqOH7/Ue0fP8ilV31vlDp6/W8sfbNyGev98G0D7/Zn9PwulfX1/25+xfayQ1nmeUW7gDa6f5cvunCpz6ivyXfV3LmjrNwYTYfra+PtQhN6exPovtuXDLc/avYLSO9da54VtsfKRXvv7brTKdtlB30pHTVnP2r9ER2povKqPaO309pPVrJlLTkof1bDGgp8d22Oe8fNys2wdY6xXquVL7Wa7Sl8f2s73PMEt/1oNhPj/N/Plaz+f7trsgX1IU/JTN3xz/9FM2fzf/pp//u0/i+D7OLzzXEHMtr7d1nr5rWJ1vOfNx/wFDe6ePapc2tGXv/m3ThqcNHto7uW9au96paQ3T09NShtYfMKz/0LTBHtvhNNw5/V6nxzC8+VZnXevhzcfJ928hD56X1zK8FZTp32u9/PLYcrH+Xfsw7gHG4OvPpwOn5Rv2ZU3W23BrfCH4+AyP7Qhz+Fu+w7eqy7rre6GrxCq0M2uUdfcSgf4dNWPdJSmH7Tlf7cId/r+Qq/wcavs3o9eGZNBvLofnfH36amWN15eHb/cp627Svn6RLH39S72V7utf6rbPSQvW39nPV7vvWGOyj6ngWJNCHOILs/1Ne4zW1zjpN9T2c7jt92H/4LVO+vU9978pqwz+P/vu5fbf2W+FPQ6v9/XlG6MirtKXdQmF9fVZbK+VqmEBh5h8sf8f2noFs6y3FQA=",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_note_internal",
         "decompose_hint",
@@ -5224,110 +5247,8 @@
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "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",
-      "artifact_hash": "74acc0382b362be946a173c5740463f2803bc3a9-1025a97fbf726aa02db0d7f6bb5a868f-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"
-          },
-          "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": 3,
-              "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": "51138cca3416c965bb4ccec1358c0c804a4ada84-a9f8c3b60c3f877d5774ce939baba0f8-mega-honk-true"
     }
   ],
   "outputs": {
@@ -5463,60 +5384,6 @@
     },
     "structs": {
       "functions": [
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner_hash",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrAccount::verify_private_authwit_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrAccount::verify_private_authwit_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "signing_pub_key_x",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "signing_pub_key_y",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrAccount::constructor_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrAccount::constructor_abi"
-        },
         {
           "fields": [
             {
@@ -5699,6 +5566,60 @@
           ],
           "kind": "struct",
           "path": "SchnorrAccount::entrypoint_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "signing_pub_key_x",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "signing_pub_key_y",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "SchnorrAccount::constructor_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "SchnorrAccount::constructor_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "SchnorrAccount::verify_private_authwit_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "SchnorrAccount::verify_private_authwit_abi"
         }
       ]
     }
@@ -5714,7 +5635,7 @@
     },
     "7": {
       "path": "std/collections/bounded_vec.nr",
-      "source": "use crate::{cmp::Eq, convert::From};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if !exceeded_len {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n        for i in 0..MaxLen {\n            if i < self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        }\n        ret\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        (self.len == other.len) & (self.storage == other.storage)\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n}\n"
+      "source": "use crate::{cmp::Eq, convert::From};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if !exceeded_len {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n        for i in 0..MaxLen {\n            if i < self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        }\n        ret\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n        for i in 0..MaxLen {\n            if i >= len {\n                array[i] = zeroed;\n            }\n        }\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n}\n"
     },
     "17": {
       "path": "std/embedded_curve_ops.nr",
@@ -5734,7 +5655,7 @@
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        if message_size == N {\n            Poseidon2::hash_internal(input, N, false)\n        } else {\n            Poseidon2::hash_internal(input, message_size, true)\n        }\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
     "27": {
       "path": "std/hash/sha256.nr",
@@ -5748,197 +5669,205 @@
       "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"
     },
-    "65": {
-      "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"
-    },
-    "67": {
-      "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"
-    },
-    "68": {
-      "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"
+    "54": {
+      "path": "std/schnorr.nr",
+      "source": "use crate::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar};\n\n// docs:start:schnorr_verify\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool\n// docs:end:schnorr_verify\n{\n    //scalar lo/hi from bytes\n    let sig_s = EmbeddedCurveScalar::from_bytes(signature, 0);\n    let sig_e = EmbeddedCurveScalar::from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = EmbeddedCurveScalar::from_bytes(signature, 0);\n    let sig_e = EmbeddedCurveScalar::from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let r = crate::embedded_curve_ops::multi_scalar_mul([g1, public_key], [sig_s, sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = crate::hash::pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = crate::hash::blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\n#[test]\nfn test_zero_signature() {\n    let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let signature: [u8; 64] = [0; 64];\n    let message: [u8; _] = [2; 64]; // every message\n    let verified = verify_signature(public_key, signature, message);\n    assert(!verified);\n}\n"
     },
-    "71": {
-      "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"
-    },
-    "72": {
-      "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` have authorized the current call with a valid authentication witness\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making 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 have 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 have 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 allow 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` have authorized the current call in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making 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 have 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` have authorized a speicifc `inner_hash` in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making 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 have 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 * Computs 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 have 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"
-    },
-    "84": {
+    "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"
     },
-    "87": {
+    "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"
     },
-    "91": {
+    "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"
     },
-    "94": {
+    "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"
     },
-    "101": {
+    "92": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr",
       "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Deserialize};\n\npub struct UnconstrainedContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "102": {
+    "93": {
       "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        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\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_ENCRYPTED_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_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, 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 note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_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            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: 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            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.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    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\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            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: 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 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"
     },
-    "108": {
+    "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"
     },
-    "119": {
+    "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"
     },
-    "120": {
+    "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"
     },
-    "121": {
+    "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 as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\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"
+      "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"
     },
-    "122": {
+    "113": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_nullifier_membership_witness.nr",
       "source": "use dep::protocol_types::{\n    abis::nullifier_leaf_preimage::{NULLIFIER_LEAF_PREIMAGE_LENGTH, NullifierLeafPreimage},\n    constants::NULLIFIER_TREE_HEIGHT,\n    utils::arr_copy_slice,\n};\n\n// INDEX_LENGTH + NULLIFIER_LEAF_PREIMAGE_LENGTH + NULLIFIER_TREE_HEIGHT\nglobal NULLIFIER_MEMBERSHIP_WITNESS: u32 = 44;\n\npub struct NullifierMembershipWitness {\n    pub index: Field,\n    pub leaf_preimage: NullifierLeafPreimage,\n    pub path: [Field; NULLIFIER_TREE_HEIGHT],\n}\n\nimpl NullifierMembershipWitness {\n    pub fn deserialize(fields: [Field; NULLIFIER_MEMBERSHIP_WITNESS]) -> Self {\n        let leaf_preimage_fields = arr_copy_slice(fields, [0; NULLIFIER_LEAF_PREIMAGE_LENGTH], 1);\n        Self {\n            index: fields[0],\n            leaf_preimage: NullifierLeafPreimage::deserialize(leaf_preimage_fields),\n            path: arr_copy_slice(\n                fields,\n                [0; NULLIFIER_TREE_HEIGHT],\n                1 + NULLIFIER_LEAF_PREIMAGE_LENGTH,\n            ),\n        }\n    }\n}\n\n#[oracle(getLowNullifierMembershipWitness)]\nunconstrained fn get_low_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_low_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_low_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n\n#[oracle(getNullifierMembershipWitness)]\nunconstrained fn get_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n"
     },
-    "123": {
+    "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"
     },
-    "124": {
+    "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"
     },
-    "126": {
+    "117": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "128": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/logs.nr",
-      "source": "use dep::protocol_types::address::AztecAddress;\n\n/// Informs the simulator that an encrypted note log has been emitted, helping it keep track of side-effects and easing\n/// debugging.\npub fn emit_encrypted_note_log<let M: u32>(\n    note_hash_counter: u32,\n    encrypted_note: [u8; M],\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        emit_encrypted_note_log_oracle_wrapper(note_hash_counter, encrypted_note, counter)\n    }\n}\n\n/// Informs the simulator that an encrypted event log has been emitted, helping it keep track of side-effects and easing\n/// debugging.\npub fn emit_encrypted_event_log<let M: u32>(\n    contract_address: AztecAddress,\n    randomness: Field,\n    encrypted_event: [u8; M],\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        emit_encrypted_event_log_oracle_wrapper(\n            contract_address,\n            randomness,\n            encrypted_event,\n            counter,\n        )\n    }\n}\n\nunconstrained fn emit_encrypted_note_log_oracle_wrapper<let M: u32>(\n    note_hash_counter: u32,\n    encrypted_note: [u8; M],\n    counter: u32,\n) {\n    emit_encrypted_note_log_oracle(note_hash_counter, encrypted_note, counter)\n}\n\nunconstrained fn emit_encrypted_event_log_oracle_wrapper<let M: u32>(\n    contract_address: AztecAddress,\n    randomness: Field,\n    encrypted_event: [u8; M],\n    counter: u32,\n) {\n    emit_encrypted_event_log_oracle(contract_address, randomness, encrypted_event, counter)\n}\n\n/// Temporary substitute that is used for handling contract class registration. This\n/// variant returns the log hash, which would be too large to compute inside a circuit.\npub unconstrained fn emit_contract_class_unencrypted_log_private<let N: u32>(\n    contract_address: AztecAddress,\n    message: [Field; N],\n    counter: u32,\n) -> Field {\n    emit_contract_class_unencrypted_log_private_oracle(contract_address, message, counter)\n}\n\n// = 480 + 32 * N bytes\n#[oracle(emitEncryptedNoteLog)]\nunconstrained fn emit_encrypted_note_log_oracle<let M: u32>(\n    _note_hash_counter: u32,\n    _encrypted_note: [u8; M],\n    _counter: u32,\n) {}\n\n#[oracle(emitEncryptedEventLog)]\nunconstrained fn emit_encrypted_event_log_oracle<let M: u32>(\n    _contract_address: AztecAddress,\n    _randomness: Field,\n    _encrypted_event: [u8; M],\n    _counter: u32,\n) {}\n\n#[oracle(emitContractClassLog)]\nunconstrained fn emit_contract_class_unencrypted_log_private_oracle<let N: u32>(\n    contract_address: AztecAddress,\n    message: [Field; N],\n    counter: u32,\n) -> Field {}\n"
-    },
-    "129": {
+    "120": {
       "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"
     },
-    "134": {
+    "125": {
       "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"
     },
-    "135": {
+    "126": {
       "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"
     },
-    "137": {
+    "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"
     },
-    "138": {
+    "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_BYTES,\n    hash::sha256_to_field, public_keys::OvpkM,\n};\n\n/// Computes private note log payload and a log hash\nfn compute_payload_and_hash<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    ovsk_app: Field,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> (u32, [u8; PRIVATE_LOG_SIZE_IN_BYTES], Field)\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 encrypted_log = compute_private_log_payload(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        sender,\n        plaintext,\n    );\n    let log_hash = sha256_to_field(encrypted_log);\n\n    (note_hash_counter, encrypted_log, log_hash)\n}\n\nunconstrained fn compute_payload_and_hash_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    ovpk: OvpkM,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> (u32, [u8; PRIVATE_LOG_SIZE_IN_BYTES], Field)\nwhere\n    Note: NoteInterface<N>,\n{\n    let ovsk_app = get_ovsk_app(ovpk.hash());\n    compute_payload_and_hash(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 (note_hash_counter, encrypted_log, log_hash) =\n            compute_payload_and_hash(*context, e.note, ovsk_app, ovpk, recipient, sender);\n        context.emit_raw_note_log(note_hash_counter, encrypted_log, log_hash);\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        //   Having the log hash be unconstrained here is fine because the way this works is we send the log hash\n        // to the kernel, and it gets included as part of its public inputs. Then we send the tx to the sequencer,\n        // which includes the kernel proof and the log preimages. The sequencer computes the hashes of the logs\n        // and checks that they are the ones in the public inputs of the kernel, and drops the tx otherwise (proposing\n        // the block on L1 would later fail if it didn't because of txs effects hash mismatch).\n        //   So if we don't constrain the log hash, then a malicious sender can compute the correct log, submit a bad\n        // log hash to the kernel, and then submit the bad log preimage to the sequencer. All checks will pass, but\n        // the submitted log will not be the one that was computed by the app.\n        //   In the unconstrained case, we don't care about the log at all because we don't do anything with it,\n        // and because it's unconstrained: it could be anything. So if a sender chooses to broadcast the tx with a log\n        // that is different from the one that was used in the circuit, then they'll be able to, but they were already\n        // able to change the log before anyway, so the end result is the same. 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        //   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        let (note_hash_counter, encrypted_log, log_hash) = unsafe {\n            compute_payload_and_hash_unconstrained(*context, e.note, ovpk, recipient, sender)\n        };\n        context.emit_raw_note_log(note_hash_counter, encrypted_log, log_hash);\n    }\n}\n"
+      "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"
     },
-    "139": {
+    "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"
     },
-    "141": {
+    "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_BYTES},\n    hash::poseidon2_hash_with_separator,\n    point::Point,\n    public_keys::{AddressPoint, OvpkM},\n    scalar::Scalar,\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_bytes_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::point::point_to_bytes,\n};\n\npub comptime global PRIVATE_LOG_OVERHEAD_IN_BYTES: u32 = 304;\n\n// 1 byte for storage slot, 1 byte for note type id, allowing 6 bytes for custom note fields.\nglobal MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 = 8 * 32;\n\nglobal MAX_PRIVATE_EVENT_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n    MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES - 32; // Reserve 1 field for address tag.\n\n// PRIVATE_LOG_SIZE_IN_BYTES\n// - PRIVATE_LOG_OVERHEAD_IN_BYTES, consisting of:\n//   - 32 bytes for incoming_tag\n//   - 32 bytes for eph_pk\n//   - 48 bytes for incoming_header\n//   - 48 bytes for outgoing_header\n//   - 144 bytes for outgoing_body\n// - 16 + MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES for incoming_body, consisting of:\n//   - 1 byte for plaintext length\n//   - MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES for the actual plaintext and padded random values\n//   - 15 bytes for AES padding\n\n// Note: Update PRIVATE_LOG_SIZE_IN_BYTES in `constants.nr` if any of the above fields change.\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) -> [u8; PRIVATE_LOG_SIZE_IN_BYTES] {\n    let extended_plaintext: [u8; MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES + 1] =\n        extend_private_log_plaintext(plaintext);\n    compute_encrypted_log(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        sender,\n        extended_plaintext,\n    )\n}\n\npub fn compute_event_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) -> [u8; PRIVATE_LOG_SIZE_IN_BYTES] {\n    let extended_plaintext: [u8; MAX_PRIVATE_EVENT_LOG_PLAINTEXT_SIZE_IN_BYTES + 1] =\n        extend_private_log_plaintext(plaintext);\n    compute_encrypted_log(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        sender,\n        extended_plaintext,\n    )\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 + 1] = extend_private_log_plaintext(plaintext);\n    compute_encrypted_log(\n        contract_address,\n        ovsk_app,\n        ovpk,\n        recipient,\n        sender,\n        extended_plaintext,\n    )\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    sender: 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; 144] =\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    // 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_bytes = unsafe { get_app_tag_bytes_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n    for i in 0..32 {\n        encrypted_bytes[offset + i] = tag_bytes[i];\n    }\n    offset += 32;\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..48 {\n        encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n        encrypted_bytes[offset + 48 + i] = outgoing_header_ciphertext[i];\n    }\n    offset += 48 * 2;\n\n    // outgoing_body\n    for i in 0..144 {\n        encrypted_bytes[offset + i] = outgoing_body_ciphertext[i];\n    }\n    offset += 144;\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 as u8;\n    for i in 0..P {\n        padded[i + 1] = 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; 144] {\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; 128];\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..32 {\n        buffer[i] = serialized_eph_sk_high[i];\n        buffer[i + 32] = serialized_eph_sk_low[i];\n        buffer[i + 64] = address_bytes[i];\n    }\n    for i in 0..32 {\n        buffer[i + 96] = 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 = 0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f;\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 log = 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 encrypted_log_from_typescript = [\n            14, 156, 255, 195, 221, 215, 70, 175, 251, 2, 65, 13, 143, 10, 130, 62, 137, 147, 151,\n            133, 188, 200, 232, 142, 228, 243, 202, 224, 94, 115, 124, 54, 141, 70, 12, 14, 67, 77,\n            132, 110, 193, 234, 40, 110, 64, 144, 235, 86, 55, 111, 242, 123, 221, 193, 170, 202,\n            225, 216, 86, 84, 159, 112, 31, 167, 5, 119, 121, 10, 234, 188, 194, 216, 30, 200, 208,\n            201, 158, 127, 93, 43, 242, 241, 69, 32, 37, 220, 119, 122, 23, 132, 4, 248, 81, 217,\n            61, 232, 24, 146, 63, 133, 24, 120, 113, 217, 155, 223, 149, 214, 149, 239, 240, 169,\n            224, 155, 161, 81, 83, 252, 155, 77, 34, 75, 110, 30, 113, 223, 189, 202, 171, 6, 192,\n            157, 91, 60, 116, 155, 254, 190, 28, 4, 7, 236, 205, 4, 245, 27, 187, 89, 20, 38, 128,\n            200, 160, 145, 185, 127, 198, 203, 207, 97, 246, 194, 175, 155, 142, 188, 143, 120, 83,\n            122, 178, 63, 208, 197, 232, 24, 228, 212, 45, 69, 157, 38, 90, 219, 119, 194, 239, 130,\n            155, 246, 143, 135, 242, 196, 123, 71, 139, 181, 122, 231, 228, 26, 7, 100, 63, 101,\n            195, 83, 8, 61, 85, 123, 148, 227, 29, 164, 162, 161, 49, 39, 73, 141, 46, 179, 240, 52,\n            109, 165, 238, 210, 233, 188, 36, 90, 175, 2, 42, 149, 78, 208, 176, 145, 50, 180, 152,\n            245, 55, 112, 40, 153, 180, 78, 54, 102, 119, 98, 56, 235, 246, 51, 179, 86, 45, 127,\n            18, 77, 187, 168, 41, 24, 232, 113, 149, 138, 148, 33, 143, 215, 150, 188, 105, 131,\n            254, 236, 199, 206, 56, 44, 130, 134, 29, 99, 254, 69, 153, 146, 68, 234, 148, 148, 178,\n            38, 221, 182, 103, 252, 139, 7, 246, 132, 29, 232, 78, 102, 126, 28, 136, 8, 219, 180,\n            162, 14, 62, 71, 118, 40, 147, 93, 87, 188, 231, 32, 93, 56, 193, 194, 197, 120, 153,\n            164, 139, 114, 18, 149, 2, 226, 19, 170, 250, 249, 128, 56, 236, 93, 14, 101, 115, 20,\n            173, 73, 192, 53, 229, 7, 23, 59, 11, 176, 9, 147, 175, 168, 206, 48, 127, 126, 76, 51,\n            211, 66, 232, 16, 132, 243, 14, 196, 181, 118, 12, 71, 236, 250, 253, 71, 249, 122, 30,\n            23, 23, 19, 89, 47, 193, 69, 240, 164, 34, 128, 110, 13, 133, 198, 7, 165, 14, 31, 239,\n            210, 146, 78, 67, 86, 32, 159, 244, 214, 246, 121, 246, 233, 252, 20, 131, 221, 28, 146,\n            222, 119, 222, 162, 250, 252, 189, 18, 147, 12, 142, 177, 222, 178, 122, 248, 113, 197,\n            40, 199, 152, 251, 91, 81, 243, 25, 156, 241, 141, 60, 12, 99, 103, 169, 97, 32, 112,\n            37, 244, 255, 126, 46, 114, 226, 113, 223, 249, 27, 3, 31, 41, 233, 28, 8, 23, 84, 99,\n            25, 186, 65, 33, 9, 35, 74, 16, 52, 169, 48, 161, 134, 233, 242, 136, 39, 162, 105, 205,\n            43, 253, 183, 36, 138, 186, 87, 31, 7, 248, 125, 227, 193, 172, 155, 98, 33, 61, 186,\n            158, 241, 192, 23, 28, 186, 100, 222, 174, 19, 64, 224, 113, 251, 143, 45, 152, 81, 67,\n            116, 16, 95, 189, 83, 31, 124, 39, 155, 142, 66, 0, 120, 197, 221, 161, 62, 75, 192,\n            255, 186, 200, 10, 135, 7,\n        ];\n        assert_eq(encrypted_log_from_typescript, log);\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            127, 182, 227, 75, 192, 197, 54, 47, 168, 134, 233, 148, 251, 46, 86, 12, 73, 50, 238,\n            50, 31, 174, 27, 202, 110, 77, 161, 197, 244, 124, 17, 100, 143, 150, 232, 14, 156, 248,\n            43, 177, 16, 82, 244, 103, 88, 74, 84, 200, 15, 65, 187, 14, 163, 60, 91, 22, 104, 31,\n            211, 190, 124, 121, 79, 92, 238, 182, 194, 225, 34, 71, 67, 116, 27, 231, 68, 161, 147,\n            94, 53, 195, 83, 237, 172, 52, 173, 229, 26, 234, 107, 43, 82, 68, 16, 105, 37, 125,\n            117, 86, 133, 50, 21, 92, 74, 229, 105, 141, 83, 229, 255, 251, 21, 61, 234, 61, 168,\n            221, 106, 231, 8, 73, 208, 60, 251, 46, 251, 228, 148, 144, 187, 195, 38, 18, 223, 153,\n            8, 121, 178, 84, 237, 148, 254, 219, 59, 62,\n        ];\n\n        assert_eq(outgoing_body_ciphertext_from_typescript, ciphertext);\n    }\n}\n"
+      "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": {
+    "142": {
       "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"
     },
-    "153": {
+    "144": {
       "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"
     },
-    "154": {
+    "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"
     },
-    "161": {
+    "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"
     },
-    "180": {
+    "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"
     },
-    "185": {
+    "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"
     },
-    "192": {
+    "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"
     },
-    "195": {
+    "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"
     },
-    "197": {
+    "188": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/traits.nr",
       "source": "use crate::meta::{derive_deserialize, derive_serialize};\nuse crate::utils::field::field_from_bytes;\n\n// Trait: is_empty\n//\n// The general is_empty trait checks if a data type is is empty,\n// and it defines empty for the basic data types as 0.\n//\n// If a Field is equal to zero, then it is regarded as zero.\n// We will go with this definition for now, however it can be problematic\n// if a value can actually be zero. In a future refactor, we can\n// use the optional type for safety. Doing it now would lead to a worse devex\n// and would make it harder to sync up with the cpp code.\n// Preferred over Default trait to convey intent, as default doesn't necessarily mean empty.\npub trait Empty {\n    fn empty() -> Self;\n}\n\nimpl Empty for Field {\n    fn empty() -> Self {\n        0\n    }\n}\n\nimpl Empty for u1 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u8 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u32 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for u64 {\n    fn empty() -> Self {\n        0\n    }\n}\nimpl Empty for U128 {\n    fn empty() -> Self {\n        U128::from_integer(0)\n    }\n}\n\npub fn is_empty<T>(item: T) -> bool\nwhere\n    T: Empty + Eq,\n{\n    item.eq(T::empty())\n}\n\npub fn is_empty_array<T, let N: u32>(array: [T; N]) -> bool\nwhere\n    T: Empty + Eq,\n{\n    array.all(|elem| is_empty(elem))\n}\n\npub trait Hash {\n    fn hash(self) -> Field;\n}\n\npub trait ToField {\n    fn to_field(self) -> Field;\n}\n\nimpl ToField for Field {\n    fn to_field(self) -> Field {\n        self\n    }\n}\n\nimpl ToField for bool {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u1 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u8 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u32 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for u64 {\n    fn to_field(self) -> Field {\n        self as Field\n    }\n}\nimpl ToField for U128 {\n    fn to_field(self) -> Field {\n        self.to_integer()\n    }\n}\nimpl<let N: u32> ToField for str<N> {\n    fn to_field(self) -> Field {\n        assert(N < 32, \"String doesn't fit in a field, consider using Serialize instead\");\n        field_from_bytes(self.as_bytes(), true)\n    }\n}\n\npub trait FromField {\n    fn from_field(value: Field) -> Self;\n}\n\nimpl FromField for Field {\n    fn from_field(value: Field) -> Self {\n        value\n    }\n}\n\nimpl FromField for bool {\n    fn from_field(value: Field) -> Self {\n        value as bool\n    }\n}\nimpl FromField for u1 {\n    fn from_field(value: Field) -> Self {\n        value as u1\n    }\n}\nimpl FromField for u8 {\n    fn from_field(value: Field) -> Self {\n        value as u8\n    }\n}\nimpl FromField for u32 {\n    fn from_field(value: Field) -> Self {\n        value as u32\n    }\n}\nimpl FromField for u64 {\n    fn from_field(value: Field) -> Self {\n        value as u64\n    }\n}\nimpl FromField for U128 {\n    fn from_field(value: Field) -> Self {\n        U128::from_integer(value)\n    }\n}\n\n// docs:start:serialize\n#[derive_via(derive_serialize)]\npub trait Serialize<let N: u32> {\n    fn serialize(self) -> [Field; N];\n}\n// docs:end:serialize\n\nimpl<let N: u32> Serialize<N> for str<N> {\n    fn serialize(self) -> [Field; N] {\n        let bytes = self.as_bytes();\n        let mut fields = [0; N];\n        for i in 0..bytes.len() {\n            fields[i] = bytes[i] as Field;\n        }\n        fields\n    }\n}\n\n// docs:start:deserialize\n#[derive_via(derive_deserialize)]\npub trait Deserialize<let N: u32> {\n    fn deserialize(fields: [Field; N]) -> Self;\n}\n// docs:end:deserialize\n\nimpl<let N: u32> Deserialize<N> for str<N> {\n    fn deserialize(fields: [Field; N]) -> Self {\n        str<N>::from(fields.map(|value| value as u8))\n    }\n}\n"
     },
-    "200": {
+    "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"
     },
-    "202": {
+    "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"
     },
-    "203": {
+    "194": {
       "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"
     },
-    "204": {
+    "195": {
       "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"
     },
-    "229": {
+    "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, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\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 silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\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"
+      "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"
     },
-    "267": {
+    "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"
     },
-    "295": {
+    "261": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/abis/nullifier_leaf_preimage.nr",
+      "source": "pub global NULLIFIER_LEAF_PREIMAGE_LENGTH: u32 = 3;\n\nuse crate::{\n    abis::{read_request::ScopedReadRequest, side_effect::Readable},\n    hash::compute_siloed_nullifier,\n    merkle_tree::leaf_preimage::{IndexedTreeLeafPreimage, LeafPreimage},\n    traits::{Empty, Hash},\n};\n\npub struct NullifierLeafPreimage {\n    pub nullifier: Field,\n    pub next_nullifier: Field,\n    pub next_index: u32,\n}\n\nimpl Empty for NullifierLeafPreimage {\n    fn empty() -> Self {\n        Self { nullifier: 0, next_nullifier: 0, next_index: 0 }\n    }\n}\n\nimpl Hash for NullifierLeafPreimage {\n    fn hash(self) -> Field {\n        if self.is_empty() {\n            0\n        } else {\n            crate::hash::poseidon2_hash(self.serialize())\n        }\n    }\n}\n\nimpl LeafPreimage for NullifierLeafPreimage {\n    fn get_key(self) -> Field {\n        self.nullifier\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n}\n\nimpl IndexedTreeLeafPreimage<Field> for NullifierLeafPreimage {\n    fn get_key(self) -> Field {\n        self.nullifier\n    }\n\n    fn get_next_key(self) -> Field {\n        self.next_nullifier\n    }\n\n    fn points_to_infinity(self) -> bool {\n        (self.next_nullifier == 0) & (self.next_index == 0)\n    }\n\n    fn as_leaf(self) -> Field {\n        self.hash()\n    }\n\n    fn update_pointers(self, next_key: Field, next_index: u32) -> Self {\n        Self { nullifier: self.nullifier, next_nullifier: next_key, next_index }\n    }\n\n    fn update_value(self, _nullifier: Field) -> Self {\n        assert(false, \"Tried to update a nullifier\");\n        Self::empty()\n    }\n\n    fn build_insertion_leaf(nullifier: Field, low_leaf: Self) -> Self {\n        Self { nullifier, next_nullifier: low_leaf.next_nullifier, next_index: low_leaf.next_index }\n    }\n}\n\nimpl Readable<ScopedReadRequest> for NullifierLeafPreimage {\n    fn assert_match_read_request(self, read_request: ScopedReadRequest) {\n        let siloed_value =\n            compute_siloed_nullifier(read_request.contract_address, read_request.value());\n        assert_eq(\n            self.nullifier,\n            siloed_value,\n            \"Value of the nullifier leaf does not match read request\",\n        );\n    }\n}\n\nimpl NullifierLeafPreimage {\n    pub fn is_empty(self) -> bool {\n        (self.nullifier == 0) & (self.next_nullifier == 0) & (self.next_index == 0)\n    }\n\n    pub fn serialize(self) -> [Field; NULLIFIER_LEAF_PREIMAGE_LENGTH] {\n        [self.nullifier, self.next_nullifier, self.next_index as Field]\n    }\n\n    pub fn deserialize(fields: [Field; NULLIFIER_LEAF_PREIMAGE_LENGTH]) -> Self {\n        Self { nullifier: fields[0], next_nullifier: fields[1], next_index: fields[2] as u32 }\n    }\n}\n\nimpl Eq for NullifierLeafPreimage {\n    fn eq(self, other: Self) -> bool {\n        (self.nullifier == other.nullifier)\n            & (self.next_nullifier == other.next_nullifier)\n            & (self.next_index == other.next_index)\n    }\n}\n\n#[test]\nfn serialization_of_empty() {\n    let item = NullifierLeafPreimage::empty();\n    let serialized = item.serialize();\n    let deserialized = NullifierLeafPreimage::deserialize(serialized);\n    assert(item.eq(deserialized));\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"
     },
-    "313": {
+    "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"
     },
-    "315": {
+    "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"
     },
-    "322": {
+    "317": {
       "path": "/root/nargo/github.com/noir-lang/ecv0.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"
     },
-    "420": {
+    "334": {
+      "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": {
+      "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": {
+      "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": {
+      "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": {
+      "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"
+    },
+    "427": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/main.nr",
-      "source": "mod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrAccount {\n    use dep::std;\n\n    use dep::authwit::{\n        account::AccountActions,\n        auth::{compute_authwit_message_hash, compute_authwit_nullifier},\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n    use dep::aztec::encrypted_logs::encrypted_note_emission::encode_and_encrypt_note;\n    use dep::aztec::{hash::compute_siloed_nullifier, keys::getters::get_public_keys};\n    use dep::aztec::macros::{\n        functions::{initializer, noinitcheck, private, view},\n        storage::storage,\n    };\n    use dep::aztec::oracle::get_nullifier_membership_witness::get_low_nullifier_membership_witness;\n    use dep::aztec::prelude::{AztecAddress, PrivateContext, PrivateImmutable};\n\n    use crate::public_key_note::PublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        signing_public_key: PrivateImmutable<PublicKeyNote, Context>,\n    }\n\n    // Constructs the contract\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: Field, signing_pub_key_y: Field) {\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 = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n        let this_ovpk_m = get_public_keys(this).ovpk_m;\n        storage.signing_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 file\n    #[private]\n    #[noinitcheck]\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        // docs:start:is_valid_impl\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.signing_public_key.get_note();\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 signature of the payload bytes\n        std::schnorr::verify_signature(\n            public_key.x,\n            public_key.y,\n            signature,\n            outer_hash.to_be_bytes::<32>(),\n        )\n        // docs:end:is_valid_impl\n    }\n\n    /**\n    * @notice Helper function to check validity of private authwitnesses\n    * @param consumer The address of the consumer of the message\n    * @param message_hash The message hash of the message to check the validity\n    * @return True if the message_hash can be consumed, false otherwise\n    */\n    unconstrained fn lookup_validity(consumer: AztecAddress, inner_hash: Field) -> pub bool {\n        let public_key = storage.signing_public_key.view_note();\n\n        let message_hash = compute_authwit_message_hash(\n            consumer,\n            context.chain_id(),\n            context.version(),\n            inner_hash,\n        );\n\n        let witness: [Field; 64] = get_auth_witness(message_hash);\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n        let valid_in_private = std::schnorr::verify_signature(\n            public_key.x,\n            public_key.y,\n            signature,\n            message_hash.to_be_bytes::<32>(),\n        );\n\n        // Compute the nullifier and check if it is spent\n        // This will BLINDLY TRUST the oracle, but the oracle is us, and\n        // it is not as part of execution of the contract, so we are good.\n        let nullifier = compute_authwit_nullifier(context.this_address(), inner_hash);\n        let siloed_nullifier = compute_siloed_nullifier(consumer, nullifier);\n        let lower_wit =\n            get_low_nullifier_membership_witness(context.block_number(), siloed_nullifier);\n        let is_spent = lower_wit.leaf_preimage.nullifier == siloed_nullifier;\n\n        !is_spent & valid_in_private\n    }\n}\n"
+      "source": "mod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrAccount {\n    use dep::authwit::{\n        account::AccountActions,\n        auth::{compute_authwit_message_hash, compute_authwit_nullifier},\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n    use dep::aztec::encrypted_logs::encrypted_note_emission::encode_and_encrypt_note;\n    use dep::aztec::{hash::compute_siloed_nullifier, keys::getters::get_public_keys};\n    use dep::aztec::macros::{\n        functions::{initializer, noinitcheck, private, view},\n        storage::storage,\n    };\n    use dep::aztec::oracle::get_nullifier_membership_witness::get_low_nullifier_membership_witness;\n    use dep::aztec::prelude::{AztecAddress, PrivateContext, PrivateImmutable};\n\n    use crate::public_key_note::PublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        signing_public_key: PrivateImmutable<PublicKeyNote, Context>,\n    }\n\n    // Constructs the contract\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: Field, signing_pub_key_y: Field) {\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 = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n        let this_ovpk_m = get_public_keys(this).ovpk_m;\n        storage.signing_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 file\n    #[private]\n    #[noinitcheck]\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        // docs:start:is_valid_impl\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.signing_public_key.get_note();\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        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        // Verify signature of the payload bytes\n        schnorr::verify_signature(pub_key, signature, outer_hash.to_be_bytes::<32>())\n        // docs:end:is_valid_impl\n    }\n\n    /**\n    * @notice Helper function to check validity of private authwitnesses\n    * @param consumer The address of the consumer of the message\n    * @param message_hash The message hash of the message to check the validity\n    * @return True if the message_hash can be consumed, false otherwise\n    */\n    unconstrained fn lookup_validity(consumer: AztecAddress, inner_hash: Field) -> pub bool {\n        let public_key = storage.signing_public_key.view_note();\n\n        let message_hash = compute_authwit_message_hash(\n            consumer,\n            context.chain_id(),\n            context.version(),\n            inner_hash,\n        );\n\n        let witness: [Field; 64] = get_auth_witness(message_hash);\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        let valid_in_private =\n            std::schnorr::verify_signature(pub_key, signature, message_hash.to_be_bytes::<32>());\n\n        // Compute the nullifier and check if it is spent\n        // This will BLINDLY TRUST the oracle, but the oracle is us, and\n        // it is not as part of execution of the contract, so we are good.\n        let nullifier = compute_authwit_nullifier(context.this_address(), inner_hash);\n        let siloed_nullifier = compute_siloed_nullifier(consumer, nullifier);\n        let lower_wit =\n            get_low_nullifier_membership_witness(context.block_number(), siloed_nullifier);\n        let is_spent = lower_wit.leaf_preimage.nullifier == siloed_nullifier;\n\n        !is_spent & valid_in_private\n    }\n}\n"
     },
-    "421": {
+    "428": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/public_key_note.nr",
       "source": "use dep::aztec::{\n    keys::getters::{get_nsk_app, get_public_keys},\n    macros::notes::note,\n    note::utils::compute_note_hash_for_nullify,\n    protocol_types::{\n        address::AztecAddress, constants::GENERATOR_INDEX__NOTE_NULLIFIER,\n        hash::poseidon2_hash_with_separator,\n    },\n};\nuse dep::aztec::prelude::{NoteHeader, NullifiableNote, PrivateContext};\n\n// Stores a public key composed of two fields\n// TODO: Do we need to include a nonce, in case we want to read/nullify/recreate with the same pubkey value?\n#[note]\npub struct PublicKeyNote {\n    x: Field,\n    y: Field,\n    owner: AztecAddress,\n}\n\nimpl NullifiableNote for PublicKeyNote {\n    fn compute_nullifier(\n        self,\n        context: &mut PrivateContext,\n        note_hash_for_nullify: Field,\n    ) -> Field {\n        let owner_npk_m_hash: Field = 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            [note_hash_for_nullify, secret],\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: Field = get_public_keys(self.owner).npk_m.hash();\n        let secret = get_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [note_hash_for_nullify, secret],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n        )\n    }\n}\n\nimpl PublicKeyNote {\n    pub fn new(x: Field, y: Field, owner: AztecAddress) -> Self {\n        PublicKeyNote { x, y, owner, header: NoteHeader::empty() }\n    }\n}\n"
+    },
+    "429": {
+      "path": "/root/nargo/github.com/noir-lang/schnorrv0.1.1/src/lib.nr",
+      "source": "use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};\nuse std::hash::{blake2s, pedersen_hash};\n\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let r = multi_scalar_mul([g1, public_key], [sig_s, sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\n//Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\nfn scalar_from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n    let mut v: Field = 1;\n    let mut lo: Field = 0;\n    let mut hi: Field = 0;\n    for i in 0..16 {\n        lo = lo + (bytes[offset + 31 - i] as Field) * v;\n        hi = hi + (bytes[offset + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    let sig_s = EmbeddedCurveScalar::new(lo, hi);\n    sig_s\n}\n\nmod test {\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    use super::verify_signature;\n\n    #[test]\n    fn test_zero_signature() {\n        let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860,\n            is_infinite: false,\n        };\n        let signature: [u8; 64] = [0; 64];\n        let message: [u8; _] = [2; 64]; // every message\n        let verified = verify_signature(public_key, signature, message);\n        assert(!verified);\n    }\n\n    #[test]\n    fn smoke_test() {\n        let message: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n        let pub_key_x: Field = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;\n        let pub_key_y: Field = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;\n        let signature: [u8; 64] = [\n            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,\n            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84,\n            247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64,\n            199, 19, 84, 239, 138, 124, 12,\n        ];\n\n        let pub_key = EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };\n        let valid_signature = verify_signature(pub_key, signature, message);\n        assert(valid_signature);\n        super::assert_valid_signature(pub_key, signature, message);\n    }\n\n}\n\nmod bench {\n    use super::{assert_valid_signature, verify_signature};\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    #[export]\n    pub fn bench_verify_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) -> bool {\n        verify_signature(public_key, signature, message)\n    }\n\n    #[export]\n    pub fn bench_assert_valid_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) {\n        assert_valid_signature(public_key, signature, message)\n    }\n}\n"
     }
   }
 }