@aztec/accounts 0.77.1 → 0.78.0

package/artifacts/SchnorrSingleKeyAccount.json

@@ -3,138 +3,6 @@
   "noir_version": "1.0.0-beta.3+0000000000000000000000000000000000000000",
   "name": "SchnorrSingleKeyAccount",
   "functions": [
-    {
-      "name": "process_log",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16775516380094354375": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 40
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [
-          {
-            "name": "_log_plaintext",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 18,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_tx_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_unique_note_hashes_in_tx",
-            "type": {
-              "fields": [
-                {
-                  "name": "storage",
-                  "type": {
-                    "kind": "array",
-                    "length": 64,
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                },
-                {
-                  "name": "len",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "std::collections::bounded_vec::BoundedVec"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_first_nullifier_in_tx",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "_recipient",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
-      "debug_symbols": "tZbRCsIgGIXfxWsvpkt/61Uiwm0uBHHDbUGMvXsaUaOuz83YkV8/L/zgrKxzzXK7+tgPEzudVxaG1s5+iDmtG2dN8iH423W/zKryEUq/NkyjjSVPs00zO4laGsOZi135r2uTD+l9cCVVG/+bJ/keJvpMKrFdeAYQGmDQgCMYoCs0QKABEg2o0YADGqDQALTJGm2yRpus0SYT2mRCm0xokwltMqFNJrTJhDaZ0CYT1OQtp7tN3jbBvRtOv8R2V3jmx+h+us+YhtZ1S3KlBX0LUHmNB8mVLNcu9gpTcWFUhmTQEw==",
-      "brillig_names": [
-        "process_log"
-      ]
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "ZY5bCoMwEEX3Mt/5MGoF3YoUiTpKICQhj0IJ2XsnIjS0P5e5w+FyEuy4xnOR+jAepjmBMpsI0mhqKTNYnVRKnkv9hqYE7y7eW6FL9UG4ABPvxnZggHq/7mGkjUMqLK3J7I8n/KZ7zr/s0OdnpvoSTopV4W1zRL1VcuFt8cfTOrPhHh0W40qWcuYP1jY0S9Mf",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -1926,7 +1794,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "7Z3ZjuxGkm3/Rc968MF8ql9pFBo1qBsCBKlQwwUuCvXvN05mkhEnBvMbMgbDaNv6oZGpInlsb2e4LyMjt//7h7/+9Od//e9///zr//z2jx/+8F///uGX3/7yp3/+/Nuvp9/+/UPOH//tH3/706/ffv3HP//093/+8IdEtf34w0+//vX0Y8npPz/+8D8///LTD3+I6fTz7dEp1OXolPp69KB7B/e+XnrUwB8cy4jL0aef8/nw1Mq942vpy+G1tfPR417dMde8HE0xfHf0H3/8IZNb88ia4tY8sqa6NY+saW7NI2u6W/PImuHWPLCGglvzyJro1jyyJrk1j6xxGn5oDbk1j6xxGn5ojdPwQ2uchh9a4zT80Bqn4UfWFKfhh9Y4DT+0xmn4oTVOww+tIbfmkTVOww+tcRp+aI3T8ENrnIYfWuM0/Mia6jT80Bqn4YfWOA0/tMZp+KE15NY8ssZp+KE1TsMPrXEafmiN0/BDa5yGH1nTnIYfWuM0/NAap+GH1jgNP7SG3JpH1jgNP7RGOw0XOltT+8SaFNNaSaQitEY7Db/RGu00/EZrHtBwiGdr8sQaiqV8HU1xxPXoRt/+hR5e/i/cZbPa0tcpdZxll3J/BNI6RYWz/6XdObitfnaq66E13jm0p7iU3VNJk3Ftg5aj2xh5cnQuy01A6WJU796NaZWXcij8wTHH1Yuc4+TgEMdycLi8cT/HJfm4qByX7OOiclzIx0XluBQfF5XjUn1cVI5L83FROS7dx0XluAwfF43jMoKPi8px8X5f57h4v69zXLzf1zku5OOicly839c5Lt7v6xwX7/d1jov3+zrHxft9leMSgzf8SgfGO36lA+Mtv9KB8Z5f6cCQD4zOgfGuX+nAeNuvdGC871c6MN748wPTVvtSu/jy8X2vW1suHNsosoHxzl/nwERx51/PH9+aJgNTx/J9/9bOn/SafCq7HZjoA6NzYJIPjM6ByT4wOgeGfGB0DkzxgdE5MNUHRufANB8YnQPTfWB0DszwgVE5MMk7f6UD452/0oHxzl/pwHjnr3RgyAdG58B4588PzLvexyTv/JUOjPydP53j4PrgBwbe7e5u7+j2cLf3czuLG+8WzsWUyLt9+iitGXsngLi88kcxUVMxSVMxWVMxpKmYoqmYqqmYpqmYrqmYoagY0jQDk6YZmDTNwKRpBiZNMzBpmoFJ0wxMmmZg0jQDk6YZuGiagYumGbhomoGLphm4aJqBi6YZuGiagYumGbhomoGLphm4apqBq6YZuGqagaumGbhqmoGrphm4apqBq6YZuGqagaumGbhpmoGbphm4aZqBm6YZuGmagZumGbhpmoGbphm4aZqBm6YZuGuagbumGbhrmoG7phm4a5qBu6YZuGuagbumGbhrmoG7phl4aJqBh6YZeGiagYemGXhomoGHphl4aJqBh6YZeGiagce+M3BO52Lq5MqJlmPTxRfXSr1z6KnKuBYcz9sbx37n4H6+cE81XR58ciSF4I5cORLdkStHkjty5Uh2R64cIXfkypHijlw5Ut2RK0eaO3LlSHdHrhxxZr1yJDqzXjvizHrtiDPrtSPOrNeOkDty5Ygz67UjzqzXjjizXjvizHrtiDPrlSPJmfXaEWfWa0ecWa8dcWa9doTckStHnFmvHXFmvXbEmfXaEWfWa0ecWa8cyc6s1444s1474sx67YgJZm1pzRVrqdKNSEIQaYIsZyJNwGJLYwl+azneijTBfzORJpBuJtIEpU1Ekgnwmok0wVKT2ZVM4NFMJALx7JxC9qbPpBHi4UUiEA8hEA8hEA8hEE9BIJ6CQDwFgXgKAvHsnPr3JpEIz3gKAvEUBOIpCMRTEIinIhBPNUI8vEgjxMOLNEI8vEhCEIlAPNUI8fAijRAPL9II8fAijRAPK7IhEE9DIJ6GQDwNgXh2TrV9k0iEt1oN4RlPQ3jG0xCe8TQE4ulGiIcXifBWqyO81eoIb7V2TpF+z+zaEYinIxBPRyCejkA8HeGt1kB4xjMQnvEMhGc8A4F4dk5tf5NIhLdaA+Gt1kB4qzUQiMdG2j4vMtsI0J+JBCCebCPmfiYS4K1WDoQgEuAZT7YRGT8TCUA82Uaw+0wkwFutbCN+fSYS4K1WthGSPpldbeSez0QSgkgE4rEROD4TCfBWK9uIBZ+JRHjGYyO8eyYSgXhsRGzPRAK81co2grBnIgHeamUbcdWz2RWBeGyESs9EIhCPjejnmUiEt1o2AppnIhGe8VjJXOZFIhCPlcxlXiTCWy0rmcu8SIS3WgiZy9lK5jIvEoF4rGQu8yIJQSTCWy2EzOWMkLmcETKXs5XMZZZ4rGQu8yIR3mohZC5nhMzlbCVzmZ1drWQu8yIRiAchczkjZC5nhMzljJC5nBEylzNC5nK2krnMEo+VzGVeJMJbLYTM5YyQuZytZC7zsysC8SBkLmeEzOWMkLmcETKXM0LmckbIXM4ImcvZSuYySzxWMpd5kQhvtRAylzNC5nK2krnMzq5WMpd5kYQgEoF4EDKXM0LmckbIXM4ImcsZIXM5W8lcZonHSuYyLxLhrRZC5nJGyFzOVjKX+dkVgXgQMpczQuYyIWQuE0LmMiFkLhNC5jIFQhAJQDxkJXOZFwnwVosQMpcJIXOZrGQus7OrlcxlXiQC8SBkLhNC5jIhZC4TQuYyIWQuE0LmMlnJXGaJx0rmMi8S4K0WIWQuE0LmMlnJXGZnVyuZy7xIBOJByFwmhMxlQshcJoTMZULIXCaEzGWykrnMEo+VzGVeJMJbLYTMZULIXCYrmcv87IpAPAiZy4SQuUwImcuEkLlMCJnLhJC5TAiZy2Qlc5klHiuZy7xIhLdaCJnLhJC5TFYyl9nZ1UrmMi+SEEQiEA9C5jIhZC4TQuYyIWQuE0LmMlnJXGaJx0rmMi8S4a0WQuYyIWQuk5XMZX52RSAehMxlQshcJoTMZULIXCaEzGVCyFwmhMxlspK5zBKPlcxlXiTCWy2EzGVCyFwmK5nL7OxqJXOZF4lAPAiZy4SQuUwImcuEkLlMCJnLhJC5TFYyl1nisZK5zItEeKuFkLlMCJnLZCVzmZ1drWQu8yIRiAchc5kQMpcJIXO5IGQuF4TM5YKQuVysZC5zxFMCIYgEeKtVEDKXC0LmcrGSuczPrgjEg5C5XBAylwtC5nJByFwuCJnLBSFzuSBkLhcrmcss8VjJXOZFArzVKgiZywUhc7lYyVxmZ1crmcu8SEIQiUA8CJnLBSFzuSBkLheEzOWCkLlcrGQus8RjJXOZF4nwVgshc7kgZC4XK5nL/OyKQDwImcsFIXO5IGQuF4TM5YKQuVwQMpcLQuZysZK5zBKPlcxlXiTCWy2EzOWCkLlcrGQus7OrlcxlXiQC8SBkLheEzOWCkLlcEDKXC0LmckHIXC5WMpdZ4rGSucyLRHirhZC5XBAyl4uVzGV2drWSucyLRCAehMzlgpC5XBAylwtC5nJByFwuCJnLxUrmMks8VjKXeZEIb7UQMpcLQuZysZK5zM+uCMSDkLlcEDKXC0LmckHIXC4ImcsFIXO5IGQuFyuZyyzxWMlc5kUivNVCyFwuCJnLxUrmMju7Wslc5kUSgkgE4kHIXC4ImcsFIXO5IGQuV4TM5Wolc5kjnmolc5kXCfBWqwZCEAnwVqtayVzmZ1cA4qkImcsVIXO5ImQuV4TM5YqQuVwRMpcrQuZytZK5zBKPlcxlXiTAW62KkLlcETKXq5XMZXZ2tZK5zItEIB6EzOWKkLlcETKXK0LmckXIXK4ImcvVSuYySzxWMpd5kQhvtRAylytC5nK1krnMzq4ImcvVSuYyLxLhGY+VzGVeJALxIGQuVyuZy/xIIhCPlcxlXiQhiEQgHiuZy/zsivCMx0rmMi8S4Xs8RjKXKZVFJKV2I1Iv8ZTQvo4tnXiRMfWxXjefi8g1f6rUizxPqSz9rLLeqtTLPM+opLwUHInKrUqCUKmXerZUqRd7tlSpl3u2VKkXfLZUqZd8nlJZwqrypOxapeLw5S1V2mCfmUob7DNTaYR9JioJQqUV9olnlXSr0gj7tLXzopFuVRphn4lKI+wzUWmEfXiVimOYt1RphH0mKo2wz1iOjSWGW5VG2GeikiBUGmGfiUoj7DNRaYR9JiqtsE8/q7x9g6A4j/kZlYXW9bLG7zuvO2+ZQl86mBSv3qrcHp1bXerI/eLasX4YqDjr+SAG2iC2NxpoAwbfaKANznyjgeQGTgzsYzk6jzsG2qDjNxpoA7zfaKANpn+jgTbahTca6J2IzEDFGewHMdA7EaGBiJ1ISquBqY7J0bGN9RVxT+evuMZx79I5LW6kXDJ/8MmBpepcS7o8+GNoEHscLUPT4to9tYs6lqEhHxqtnxrEvuwgnxrEju8gnxrEXvIgnxrELvWFQ1MpL5c+IdaN24gtbRplvVtTmBx9ciCuZsTv/orr9uB+/vOwnmq6PPjkdlO8I4dFtxGb5fe5DdlZv81tyGb5bW6Tu72j25At7dvchuxS3+Y2ZOP5Nrche8m3ue295I5uK97ryKLb3kvu6bb3knu67b3knm6Tu72j295L7um295J7uu295J5uey+5p9veS+7otuJd5Cy67b3knm57L7mn295L7uk2uds7uu295J5uey+5p9veS+7ptveSe7rtveSObiven9Oi295L7um295J7uu295ORofmurpnhb1oMY6B2f0EBv4qYGcjthNcVb1R7EQG+1hAZ69yQzUPH2vQcx0Hsc2SqseNvhgxjonYjQQHIDZXOgdyJCA70TERronYjQQO9EhAZ6JyIzUPG22gcx0DsRGQca2Q38jQZ6JyI0kNxAmYHeiQgN9E5EuAp7JyI00DsRoYHeicgMNLLL/RsN9E5EaKB3IkIDvRMRGkhuoMxA70RknUj1TkRooHciQgO9ExEa6J2IzMDmnYhsFW7eiQgN9E5EaKB3IkIDyQ2UGeidiNBA70SEBnonIjTQOxGhgd6JyDqR7p2I0EDvRIQGeiciNNA7EaGB5AaKVuHunYjQQO9EhAZ6JyI00DsRoYHeicgMHN6JCA30TkRooHciQgO9E5F1IoPcQJmB3okIDfRORGigdyJCA70TEa7C3omIDOzBOxGhgd6JCA30TkRooHciQgPJDZQZ6J2I0EDvRIQGeici6kR68E5EaKB3IjIDo3ciQgO9ExEa6J2IbBWO3okIDSQ3UGagdyJCA70TERronYjQQO9EhAZ6JyIzMHknIjTQOxFZJ5K8ExEa6J2I0EByA2UGeiciNNA7EeEq7J2I0EDvRIQGeiciM9C3epca6J2I0EDvRIQGeiciNJDcQJmB3onIOhHfY11qoHciQgO9ExEa6J2IzEDfY124Cvse61IDvRMRGuidiNBAcgNlBnonIjTQOxGhgd6JCA30TkRooHcisk7E91iXGuidiNBA70SEBnonIjSQ3EDRKux7rEsN9E5EaKB3IkIDvRMRGuidiMxA32NdaqB3IkIDvRMRGuidiKwT8T3WpQZ6JyI00DsRoYHeiQgN9E5EuAp7JyIz0PdYlxronYjQQO9EhAZ6JyI0kNxAmYHeiQgN9E5EaKB3IrJOxPdYlxronYjMQN9jXWqgdyJCA70Tka3Cvse61EByA2UGeiciNNA7EaGB3okIDfRORGigdyIyA32PdamB3onIOhHfY11qoHciQgPJDZQZ6J2I0EDvRISrsHciQgO9ExEa6J2IyMDhe6xLDfRORGigdyJCA70TERpIbqDMQO9ERJ3I8D3WpQZ6JyI00DsRoYHeicgM9D3Whauw77EuNdA7EaGB3okIDSQ3UGagdyJCA70TERronYjQQO9EhAZ6JyLrRHyPdamB3okIDfRORGigdyJCA8kNFK3Cvse61EDvRIQGeiciNNA7EaGB3onIDPQ91qUGeiciNNA7EaGB3onIOhHfY11qoHciQgO9ExEa6J2I0EDvRISrsHciMgN9j3Wpgd6JCA30TkRooHciQgPJDZQZ6J2I0EDvRIQGeici60R8j3Wpgd6JyAz0PdalBnonIjTQOxHZKux7rEsNJDdQZqB3IkIDvRMRGuidiNBA70SEBnonIjPQ91iXGuidiKwT8T3WpQZ6JyI0kNxAmYHeiQgN9E5EuAp7JyI00DsRoYHeicgM9D3WpQZ6JyI00DsRoYHeiQgNJDdQZqB3IrJOxPdYlxronYjQQO9EhAZ6JyIz0PdYF67Cvse61EDvRIQGeiciNJDcQJmB3okIDfRORGigdyJCA70TERronYisE/E91qUGeiciNNA7EaGB3okIDSQ3ULQK+x7rUgO9ExEa6J2I0EDvRIQGeiciMjAG32Rd7KD3IlIHvRmROujdiKgbOTlI7qDQQe9HpA56QyJ10DsSqYPekkjXYu9JhA76dutiB70nkTroPYnUQe9JpA6SOyh00HsSqYPek0gd9J5E2JP4tutiB70nETroG6+LHfSeROqg9yTCtdj3Xhc7SO6g0EHvSaQOek8iddB7EqmD3pNIHfSeROigb8EudtB7EmFP4puwix30nkTqILmDQge9J5E66D2JdC32nkTqoPckUge9JxE66Juxix30nkTqoPckUge9J5E6SO6g0EHvSYQ9iW/JLnbQexKpg96TSB30nkTooG/LLl2LfV92sYPek0gd9J5E6iC5g0IHvSeROug9idRB70mkDnpPInXQexJhT+IbtIsd9J5E6qD3JFIHvSeROkjuoGwt9l3axQ56TyJ10HsSqYPek0gd9J5E6KBv1S520HsSqYPek0gd9J5E2JP4du1iB70nkTroPYnUQe9JpA56TyJdi70nETrom7aLHfSeROqg9yRSB70nkTpI7qDQQe9JpA56TyJ10HsSYU/im7eLHfSeROigb98udtB7EqmD3pMI12LfwV3sILmDQge9J5E66D2J1EHvSaQOek8iddB7EpmD0fdxFzvoPYmsJ4m+j7vYQe9JpA6SOyh00HsSqYPek0jXYu9JpA56TyJ10HsSoYO+j7vYQe9JpA56TyJ10HsSqYPkDgod9J5E2JP4Pu5iB70nkTroPYnUQe9JhA76Pu7Stdj3cRc76D2J1EHvSaQOkjsodNB7EqmD3pNIHfSeROqg9yRSB70nEfYkvo+72EHvSaQOek8iddB7EqmD5A7K1mLfx118D3pPInXQexKpg96TSB30nkTooO/jLl2LfR938T3oPYnUQe9JpA6SOyh00HsSqYPek0jXYu9JpA56TyJ10HsSoYO+j/vUQUrL0acf262DiD3J+cqppPrd0Z+m2GgzamqrKRTvyLTRC9Qe1iJiuCOTMGTaoOqpTBvoO5Vpg0+nMm1A5FSmDdKbyTSyhfVUpg1mmso0QkEzmRgUZGRb5alMDAoyskHxVCYGBRnZ6ncqE4OCjGyaO5WJQUFGtp+dysSgICMbuU5lYlCQkS1RpzIxKMjI5qJTmRgUZGSbzqlMDAoysuHlVCYGBRnZOnIqUzEFjbgUcXndezLzqYqvY3Ps57fV6W4VOeS4Hl3O7/tziHeO7iku3w7op1fh52u3e0W3Qet3CcbIk6NzWbyji28pJLpzaEpjGZOUQ+EPjjmm1eccJweHuH4xINR+efDnLaKYIP0W0XGLKKZvv0V03CKKOxe/RXTcIoq7Pr9FVNwimjeR9VtExy2i+GmD3yI6bhHFT2r8FtFxiyh+yuW3iI5bhPwW8VuEv0X86arfIpNbxJ+u+i0yuUX86arfIpNbxJ+u+i0yuUX86epBbpG2DmRqOU9GvbXzoIwiukVS8KerfotMbhEbT1dTXL5Ck3Prk1vEB93G81If9KcG3cYTUFoDPjK1OBn0RGtGSqJ+kQRz79Ip0rLOpMuVI7YvA8kN5A1MYT045XRp4J2SW/46toxxPrR/eW3jQdsrvS5rIlK6mPx+j9c2nli90Otc1+ykfLEYrBODjec5LzSQxhLtmEpu/M0aS1+b5BrCrds2Ho0cxW0bTxm0uN1Sv2fG75i1o43e3uDA2Oio1QxMO//By/dr79MDY6PrNTgwRjrTtfs5DUyaDAzR+iqATv/HD0xuK4DmfhH1eTr400ByA3kD+1pGHvcMNNJuvs9AIz3k+ww00kO+z0AjbeH7DDTS6b3NwGSkI3ufgUY6p/cZaKTDeZ+BBjuR2RcmYlhfe8Vw0VDeNbDEsZRcUqRbA8kNlBlosBPZ10CDnci+BhrsRLY1MFFdDaz11kCDnci+BhrsRHY1MBvsRPY10GAnsq2BtS1llBYn1N1qXsxotd9SdzbYtih223ucids9rm73i2+K/j63yd3e0u2xvAhrLcZbt7172tPtfVut1M9ux3R55c9qmqpq/HXEfyaP4mj5TkDupd3eXP46QmYgvbAJ+PwH5JBc8/oP9D4bodzOI3T2pqZ7I5TzYnvJhb6z/bP2dODa84Frp11rP28EHOniT2Lu1h5HHeulx2W4crv7hzw50DINnH5u3x3+qbUAaa1AWhuQ1q5Wawo5L2t2CiWP2+KH4oFqtH7hePRAN8VvsM37M8W3c/En7J8UX0s5bz3eWrktPh65+KS3+DZo5dQ2Lrq9tfh85OLpyMWXIxdfj1x8O3Lx+y5SaYzzY4vvFqmPamo48JJZ44Fh5f7O06cufgW0chEXcHpJeu/5QVz/KJjiuL3X6oE7xw32cn5f7eXAtQN1dhWos6t6O7vttWpuBDfW2jSv4Ftr1bvgb681AWnNQFrpwNDa9D7iTmGs3/E6/XzxGv3uQNVeFqm1X7RpXy/Tml4K2lioXgTaWKjmJ9ubCtULP9sK7XrJ51mhI5S16NRuhGp+zrGpUL3Ms7FQvcCzsVBCEWqHjCZC7ZDRRKgdMpoItUNGE6F2yIgXOlDIaKCQ0UAho4FCRhvsPncQoShkNFDIaKCQ0UAhowFCRjmAkFEOIGSUAwgZ5QBCRqc3aChCQcgoBxAyygGEjHIAIaMcUMgoopBRRCGjiEJGEYWMNsh9P4hQFDKKKGQUUcgoopBRNERG699s1VFuhCZDZMQLNURGvFBDZMQLNURGvFBCEWqIjHihhsiIF2qIjHihhsiIF4pCRhmFjDIKGWUUMsooZLRBIO1BhKKQUUYho4xCRhmFjDIKGREKGREKGREKGREKGSnOpt1YKAoZKU6l3VgoChmpzqPdVCgKGRUUMiooZFRQyKigkNHOubxvFIpCRgWFjAoKGRUUMiooZKQ4i3ljoShkVFHIqKKQ0c6p1G8UikJGivOuNxaKQkaKk643FopCRoozrjcWikJGitOtNxaKQkaqc603FYpCRoYysCdCUcjIUAb2RCgKGVnKwOaFopCRpQxsXigKGVnKwOaFopCRpQxsXigKGVnKwOaFopCRpQxsXigKGVnKwOaFopCRpQxsXigKGVnKwOaFopCRpQxsXigIGZGlDGxeKAgZkaUMbF4oCBlRIBShIGREljKweaEgZESWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkYoGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFNKBnYhJKBTSgZ2ISSgU0oGdiEkoFdUDKwC0oGdkHJwC4oGdglEIpQEDIqKBnYBSUDu+ycgd3OQlsdvNBYSxnL0bW1cin0s/hx4OJ3zqp+rvg26lp8T21yi/Wy3mK9xetbbOes6jcKTShCM4pQQhFaUIRWFKENRahmgtlUqGbaeU7oCGUtOt0wabJDRhOhdshoItQOGU2E2iGjiVBCEWqHjCZC7ZDRRKgdMpoItUNGE6EoZJRRyCijkFFGIaOMQkY7Z1W/USgKGWUUMsooZJRRyCijkBGhkBGhkBGhkBGhkNHOWdVvFIpCRoRCRoRCRoRCRoRCRgWFjAoKGRUUMiooZLRzVvUbhaKQUUEho4JCRgWFjAoKGVUUMqooZFRRyKiikNHOWdVvFIpCRhWFjCoKGVUUMqqGyIj9q8BmiIx4oYbIiBeqmIzaufTTzxd/+LD8qWRTTDvz4unIxSumknnxikljXrxiepgXr5gI5sUrXuWnxXfFK/e8eMWr8bz4I6+w/cgr7M7ZxBsXf+QVth95he1HXmH7kVfYfuQVdhx5hR1HXmHHkVfYceQVdueM242LP/IKO468wo4jr7DjyCvsOPAKW8OBV9gaDrzC1nDgFbaGA6+wNRx4ha3hwCtsDQdeYWs48ApbNWePzos/8gqrOXt0XvyRV1jNGaHz4o+8whrK8mRf9VdDWZ4ToQf9Jtln8buu3CmU5cIpXESG3y1+RFquPNLFle+OUQ/LEPV8NiWtMrtamczBn6WPw5a+b4LmtqWLV/cel2Njz8SXPk7/3nKrtzCZjmKt5yUm5/XgSOWrdvHi3tdo/3iZAHt/Qip5LafUi7jYeOfgkvMSR19yObuSTpf+rD0fuHY6cO1l19pP9+i6LNXC1x5HHesscEKqwH88Ug60fJhOP7dws+bJIyYPpLUBae1AWodarSnkdWY6LbMXOLYUL8+PfGHxz21rw2alV3l+5FGEJhShGUUooQjVSz5P77HF/dlQzXqxZ2OheplnY6F6gWdjoZppZ0uhZIeMJkLtkNFEqB0ymgi1Q0YToYQiFIWMCIWMCIWMCIWMCIWMCgoZFRQyKihkVFDISJ4feRShKGRUUMiooJBRQSGjgkJGFYWMKgoZVRQyqihkJM+PPIpQFDKqKGRUUcioopBRRSGjhkJGDYWMGgoZNRQykudSHkUoChk1FDJqKGTUUMiooZBRRyGjjkJGHYWMOgoZyfNEjyIUhYw6Chl1FDLqKGTUUchooJDRQCGjgUJGA4WM5DmwRxGKQkYDhYwGChkNFDIaIGTUAggZtQBCRi2AkFELIGTUAqEIBSGjFkDIqAUQMmoBhIxaQCGjiEJGEYWMIgoZRRQykucuH0UoChlFFDKKKGQUUcgoopBRQiGjhEJGCYWMEgoZ7Rxb/UahKGSkOOB6Y6EoZKQ42npjoShkZCgDeyIUhYwMZWBPhKKQkaEM7IlQFDJCycBuKBnYDSUDu6FkYDeUDOyGkoHdUDKwG0oGdkPJwG4oGdgNJQO7oWRgN5QM7IaSgd1QMrAbSgZ2Q8nAbigZ2A0lA7uhZGA3lAzshpKB3SxlYNO6t+Eot0INkREr1FIGNi/UEBnxQg2RES/UEBnxQglFqCEy4oUaIiNeqCEy4oWikJGlDGxWqKUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oCBl1SxnYvFAQMuqWMrB5oSBk1AOhCAUho24pA5sXCkJG3VIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQlHIaOcM7HEWOmrlhcZaylhtaa1cCv0svh25+K64+DbWS9d+kbN9/xY7zQtL0ZeFLLfYABG6c1b1G4VGFKEJRWhGEUooQosZoeyeD71qJphNhWqmnU2F2iGjiVA7ZMQLbXbIaCLUDhlNhNoho4lQO2Q0EUooQlHIqKGQUUMho4ZCRg2FjDoKGXUUMuooZNRRyGjnrOo3CkUho45CRh2FjDoKGXUUMhooZDRQyGigkNFAIaOds6rfKBSFjAYKGQ0UMhooZDRAyGgEEDIaAYSMRgAhoxFAyGgEQhEKQkYjgJDRCCBkNAIIGY2AQkYRhYwiChlFFDKKKGS0c1b1G4WikFFEIaOIQkYRhYwiChklFDJKKGSUUMgooZDRzlnVbxSKQkYJhYwSChklFDJKKGSUUcgoo5BRRiGjjEJGO2dVv1EoChllFDLKKGSUUcgoGyIjLhtskCEy4oUqJqN2Lv3088W1v3LEBimmnXnxiglmXjwduXjFpDEvXjE9zItXTATz4hWv8vPiFa/c0+KL4tV4XvyRV9hy5BW2HHmF3TlveOPij7zCas4Fnhd/5BVWcy7wvPgjr7Ca83vnxR95hdWcszsv/sgrrOY83HnxR15hNefWzos/8gqrOV92XvyRV1jNObDz4o+8wmrOa50Xf+QVVnOu6rz4I6+wmvNP58UfeYXVnFM6L/7IK6zmPNF58UdeYTXnfs6LP/IKqzmfc168eIVtNa//Qu+T4iktX22JVM8H13Tn4E13mhvyzM2jCG0oQjuK0AEiVJ65eRShEUVoQhGaUYQSilAUMhooZDRQyGigkNHAIKMUAgYZnYRikNFJKAYZnYRikNFJKKEIxSCjk1AMMjoJxSCjk1AMMjoJRSGjiEJGEYWMIgoZRRQykmduHkUoChlFFDKKKGQUUcgoopBRQiGjhEJGCYWMEgoZyTM3jyIUhYwSChklFDJKKGSUUMgoo5BRRiGjjEJGGYWM5JmbRxGKQkYZhYwyChllFDLKKGREKGREKGREKGREKGQkz/08ilAUMiIUMiIUMiIUMiIUMiooZFRQyKigkFFBISN5XutRhKKQUUEho4JCRgWFjAoKGVUUMqooZFRRyKiikJE8Z/coQlHIqKKQUUUho4pCRhWFjBoKGTUUMmooZNRQyEiej3wUoShk1FDIqKGQUUMho4ZCRh2FjDbIlI5r3m/PxAstOY+vg0su54PT6ejPcvZNiS55TR8u9Xzw3aziee35wLXTgWvfdxOGes63rrXwtX/bj2adBkaLgf+sphwoLh/tfGrPLg//1FqBtDYgrR1I68DROgKQ1gikNVnRWnNZCqn5e5j8VJrVKv3212a0knDJ47Z4Ulz8cxjfy4rxl4V8YfzQy0AbC9ULQBsL1Us/GwvViz4bC9XLPZsKjUEv9GwsVC/xPP2UKJS16NRuhOrFnY2FaqadTYUSilA7ZDQRaoeMJkLtkNFEqB0ymgi1Q0a80GiHjCZCUcgoopBRRCEjeRj0UYSikFFEIaOIQkYRhYwiChklFDJKKGSUUMgooZCRPAz6KEJRyCihkFFCIaOEQkYJhYwyChllFDLKKGSUUchIHgZ9FKEoZJRRyCijkFFGIaOMQkaEQkaEQkaEQkaEQkbyMOijCEUhI0IhI0IhI0IhI0Iho4JCRgWFjAoKGRUUMpKHQR9FKAoZFRQyKihkVFDIqKCQUUUho4pCRhWFjCoKGVVCEYpCRhWFjCoKGVUUMqooZNRQyKihkFFDIaOGQkbyMOijCEUho4ZCRg2FjBoKGTUUMuooZNRRyKijkFFHIaOdA6zfKBSFjBRHXW8sFIWMFIdcbywUhYwUx1tvLBSFjBQHW28sFIWMDGVgT4SikJGhDOyJUBQyMpSBPREKQkbJUAb2RCgIGSWUDOyEkoGdAqEIBSGjhJKBnVAysBNKBnZCycBOKBnYCSUDO6FkYCeUDOyEkoGdUDKwE0oGdkLJwE4oGdgJJQM7oWRgJ5QM7ISSgZ1QMrATSgZ2QsnATigZ2AklAzuhZGAnSxnYtG60OsqNUEsZ2LxQQ2TECzVERrxQQ2TECyUUoYbIiBdqiIx4oYbIiBdqiIx4oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oShkZCkDmxeKQkaWMrB5oSBklC1lYPNCQcgoW8rA5oWCkFEOhCIUhIyypQxsXigIGWVLGdi8UBQyspSBzQtFISNLGdi8UBQyspSBzQtFISNLGdi8UBQyspSBzQtFISNLGdi8UBQyspSBzQtFISNLGdi8UBQyspSBzQtFISNLGdi80H3JaJyFjlp5obGWMlZbWiuXQj+K3znXeuPio+Li21gvXftFcvr9W6yX9Ra7LOTrFts5q/qNQjOKUEIRWlCEVhShDUVoRxGqmWC2FEqaaec5oey+LJnskNFEqB0ymgi1Q0YToYQi1A4ZTYTaIaOJUDtkNBFqh4wmQu2QES+0oJBRQSGjgkJGBYWMds6qfqNQFDIqKGRUUMiooJBRQSGjikJGFYWMKgoZVRQy2jmr+o1CUcioopBRRSGjikJGFYWMGgoZNRQyaihk1FDIaOes6jcKRSGjhkJGDYWMGgoZNRQy6ihk1FHIqKOQUUcho52zqt8oFIWMOgoZdRQy6ihk1FHIaKCQ0UAho4FCRgOFjHbOqn6jUBQyGihkNFDIaKCQ0QAhIwogZEQBhIwogJARBRAyokAoQkHIiAIIGVEAISMKIGREAYWMIgoZRRQyiihkFFHIaOes6jcKRSGjiEJGEYWMIgoZRRQySihklFDIKBkiIy41lZIhMuKFEopQxWTUzqWffr649leULCXFtDMvXjHBzItXTCXz4hWTxrR4zdnP8+IVE8G8eMWr/Lx4xSv3vHjFq/G8+COvsJrzkefFH3mF1ZxjPC/+yCus5rzhefFHXmE15wLPiz/yCqs5v3de/JFXWM05u/Pij7zCas7DnRd/5BVWc27tvPgjr7Ca82XnxR95hdWcAzsv/sgrrOa81nnxR15hNeeqzos/8gqrOf90XvyRV1jNOaXz4o+8wmrOE50Xf+QVVnPu57x4Q98kY1/1W8ry5IUe9JtkH8XvnM9Z8vrpKDXyxZecl619Sy60HpxOl/6sPR649nTg2vddtp/Ztfv0kRh5/Xi0GPhPdsqB4tfhp59buP18EJDWAqS1AmltQFo7kNaBo3XntMwXaq25LIXU3Oqt0qhWaQp55YgUSh63xSfFxY/10qefv3f+zjCxu0RT18tAGwslFKF66WdjoXrRZ2OherlnY6F6oWdjoXqJ51mh/J94Db24s7FQzbSzqVA7ZDQRaoeMJkIJRagdMpoItUNGE6F2yGgi1A4ZTYSCkFEJIGRUAggZlQBCRiWAkFEJhCIUhIxKACGjEkDIqAQQMioBhYwiChlFFDKKKGQUUcho5wjMNwpFIaOIQkYRhYwiChlFFDJKKGSUUMgooZBRQiGjnSMw3ygUhYwSChklFDJKKGSUUMgoo5BRRiGjjEJGGYWMdo4jfaNQFDLKKGSUUcgoo5BRRiEjQiEjQiEjQiEjQiGjnWNk3ygUhYwIhYwIhYwIhYwIhYwKChkVFDIqKGRUUMho5/jfNwpFIaOCQkYFhYwKChkVFDKqKGRUUcioopBRRSGjnWOb3ygUhYwqChlVFDKqKGRUUciooZBRQyGjhkJGitOuNxZKKEJRyEhxyPXGQlHISHG89cZCUchIcbD1xkJRyMhQBvZEKAoZGcrAnghFISNDGdgToShkZCgDeyIUhYxQMrALSgZ2QcnALigZ2AUlA7ugZGAXlAzsgpKBXVAysAtKBnZFycCuKBnYFSUDu6JkYNdAKEJByKiiZGBXlAzsipKBXVEysCtKBnZFycCuKBnYFSUDu6JkYFeUDOyKkoFdLWVg07rR6ii3Qg2RES/UEBmxQi1lYPNCDZERL9QQGfFCDZERL5RQhBoiI16oITLihaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhaKQkaUMbF4oChlZysDmhYKQUbOUgc0LBSGjZikDmxcKQkYtEIpQEDJqljKweaEgZNQsZWDzQlHIyFIGNi8UhYwsZWDzQlHIyFIGNi8UhYwsZWDzQvclo3EWOmrlhcZaylhtaa1cCv0svh+5+KG4+DbWS9d+kZx+/xbrZb3FLgv5usV2zqp+o9CIIjShCM0oQglFaEERWlGEaiaYTYVqpp3nhLL7srRkh4x4odkOGU2E2iGjiVA7ZDQRaoeMJkIJRagdMpoItUNGE6F2yGgiFIWMMgoZEQoZEQoZEQoZEQoZ7ZxV/UahKGREKGREKGREKGREKGRUUMiooJBRQSGjgkJGO2dVv1EoChkVFDIqKGRUUMiooJBRRSGjikJGFYWMKgoZ7ZxV/UahKGRUUcioopBRRSGjikJGDYWMGgoZNRQyaihktHNW9RuFopBRQyGjhkJGDYWMGgoZdRQy6ihk1FHIqKOQ0c5Z1W8UikJGHYWMOgoZdRQy6ihkNFDIaKCQ0UAho4FCRjtnVb9RKAoZDRQyGihkNFDIaICQUQ8gZNQDCBn1AEJGPYCQUQ+EIhSEjHoAIaMeQMioBxAy6gGFjKIhMuJSU3s0REa8UENkxAtVTEbtXPrp54trf0XJ9p3zpzcuXjHBzItXTCXz4hWTxrx4xfQwL14xEUyL15znPC9e8co9L17xajwv/sgrrOZ85HnxR15hNecYz4s/8gqrOW94XvyRV1jNucDz4o+8wmrO750Xf+QVVnPO7rz4I6+wmvNw58UfeYXVnFs7L/7IK6zmfNl58UdeYTXnwM6LP/IKqzmvdV78kVdYzbmq8+KPvMJqzj+dF3/kFVZzTum8+COvsJrzROfFH3mF1Zz7OS/e0DfJ2Ff9lrI8eaEH/SbZZ/H7rtwlr5+OUiNffMl52dq35ELrwel06c/ax3Fr3zlFc9va9122n9m1+/SRGHn9eLQY+E92yoHi1+Gnn1u4+XzsnI35Xq0ZSCsBaS1AWiuQ1gaktVvRWnNZCqm51VulQ63SFPLKESmUPG6K3zkC87nix3rp08/fO39nmNhdonvTy0AbC9ULQBsL1Us/GwslFKF6uWdjoXqhZ2OheonnWaH8n3g1vbizsVDNtLOl0G6HjCZC7ZDRRKgdMpoItUNGE6GEItQOGU2E2iGjiVAUMuooZNRRyGigkNFAIaOBQkYDhYx2jsB8o1AUMhooZDRQyGigkNEAIaMRQMhoBBAyGgGEjEYAIaMRCEUoCBmNAEJGI4CQ0QggZDQCChlFFDKKKGQUUcgoopDRznGZbxSKQkYRhYwiChlFFDKKKGSUUMgooZBRQiGjhEJGO8ecvlEoChklFDJKKGSUUMgooZBRRiGjjEJGGYWMMgoZ7RxP+0ahKGSUUcgoo5BRRiGjjEJGhEJGhEJGhEJGhEJGO8cKv1EoChkRChkRChkRChkRChkVFDIqKGRUUMiooJDRznHQbxSKQkYFhYwKChkVFDIqKGRUUchIcdr1xkJRyEhxzvXGQglFKAoZKY633lgoChkpDrbeWCgKGRnKwJ4IRSEjQxnYE6EoZGQoA3siFIWMDGVgT4SikBFKBvZAycAeKBnYAyUDe6BkYA+UDOyBkoE9UDKwB0oG9kDJwB4oGdgDJQN7oGRgD5QM7IGSgT1QMrAHSgb2QMnAHigZ2AMlA3ugZGAPkAzsHEAysE9CMcjoJBSDjE5CMcjoJJRQhBoiI1o3Wh3lVqghMuKFGiIjXqghMuKFGiIjVqilDGxeqCEy4oUaIiNeqCEy4oUSilAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAUMrKUgc0LRSEjSxnYvFAQMoqWMrB5ofuS0TgLHbXyQmMtZay2tFYuhX4Wn45cfFZcfBvrpWu/SGW+f4v1st5il4UstxihCC0oQiuK0IYitKMIHSBCd86qfqNQzQSzqVDNtPOcUHbPhxjtkNFEKKEItUNGE6F2yGgi1A4ZTYTaIaOJUDtkxAtNdshoItQOGU2EopBRQiGjnbOq3ygUhYwSChklFDJKKGSUUMgoo5BRRiGjjEJGGYWMds6qfqNQFDLKKGSUUcgoo5BRRiEjQiEjQiEjQiEjQiGjnbOq3ygUhYwIhYwIhYwIhYwIhYwKChkVFDIqKGRUUMho56zqNwpFIaOCQkYFhYwKChkVFDKqKGRUUcioopBRRSGjnbOq3ygUhYwqChlVFDKqKGRUUciooZBRQyGjhkJGDYWMds6qfqNQFDJqKGTUUMiooZBRQyGjjkJGHYWMOgoZdRQy2jmr+o1CUcioo5BRRyGjjkJGHYWMBgoZDRQyGihkNFDIaOes6qeEtnMO6unni2sveZxDMe3Mi1dMMPPiFVPJvHjFpDEvXjE9zIpPQTERzItXvMrPi1e8cs+LV7waz4s/8AqbNOcjz4s/8AqbNOcYz4s/8AqbNOcNT4vXnCE8L/7IK6zmrN958UdeYTVn8s6LP/IKqzk7d178kVdYzRm38+KPvMJqzqKdF3/kFVZzZuy8+COvsJqzXefFH3mF1ZzBOi/+yCus5qzUefFHXmE1Z5rOiz/yCqs5e3Re/JFXWM0ZofPij7zCyrM8x7pt5Olhf+CL76eG/+vgnkpaD07t3qVPxS9HtzHy5OhcFhMpnctI974VkFpca2458wfH1urZwjI5OKxXjqH2y4M/7W5u9552Synm9AqIVrv75KNZc4zLhTPVy8/avYEMef0cl7MpsfSv2seutRMt5VSqga/9xCi0KD393MLNtCKOH31r8fHIxacjF5+PXDwdtPjTL3/++8+//PLz//73L7/95U///Pm3X//x7eTw7f/dB4Sel0m69wtV9/5tWufzEs/TXBkfprVXXry/8uLjhRe/P3tudfH4yovfnX16X84YcUwunmjFinJ56LeL51denF558fLKi9dXXry98uL9lRcfL7z4/RDRrS4eX3nxV35Cyys/oeWVn9Dyyk9oeeUntLzyE1pe+Qktr/yEVvGAlgXc6Nv//v3FpbaUvvStNRb+0Br6cmg695SnB0UfhQwlhbSgpZCopZCkpZCspRDSUkjRUkjVUkjTUoiWmbVpmVm7lpm1a5lZu5aZtWuZWbuWmbVrmVn7nvPI+o6tlnhdyNjzU1PXZ40XL0OWQsSfmrr+KW2sE3YOYYXncFF1DvGjlKynFNqzFAprKRevfJZSip5Sqp5S2p6l9GVKodOrxZtSup5SxrtKGdelxBAU1RIV1bLnhJtSWx+FXHwtYK0lK6qFFNWy55yb1mMptX5bS1VUS1NUy57Tbo7LW1XKF1S51jL01BKDolrim2rJdFtLUlRLVlTLnvPuxdNzquW2lqKolqqolj3nXRoreJeQb2vpimoZempJe867Ja+MWUq8rSUqqiUpqiW/q5bbPiCRolqKolr2nHdrWxmz9lvGTE1RLV1RLXvOu+3ML+0iq2+pJQdFtURFtew577b1ETO1dtsH5KyoFnpTLf2WvXNRVEtVVMvL5t2Pq/eXXn288uoUXnp16fxVx/JcrYV2c/X00qvnV1697Pnen3tx+GA71hdV0ta/XOr1tpKoppKkppKsphJSU0lRU0lVU8me36zi3v/HXb+0ylcytFSy69dW+Uq0fE8k7vrFVb6SrKYSUlNJUVNJVVOJmjm2qZljm5o5Vvx1Te4vMaL4O5g0luX7uz9n/Lq69HNPndar39ZeXnr1+tKrt5devb/06uOVVx/hpVeP2109hZurp5dePb/06uLPal1mPLr86/uvq5eXXr2+9OrtpVfvL736eOHVk/i7i/zV40uvnl569fzSq9NLr15eevXXfVZPv8RvB97/GkgMa75QDPnMZPFePkgLy1TZYro89GMBfO3lh/zyeXnl1WhcXf7+9y+evPxClK3m68tH+eVXdG6jXV8+vfbyWXz5npY7udP10N7/LsOTl18zyUq9vnyRX37N2+m35tQNLz+u7vvTL+njs3v/H4nrn6Gcfuz/f5+YuAayxVgrX9jpqu18dBiXfdhHcfnbwffvvjLWj8PF9zRO//rHifRx4v1kprzciT1cGEf58b3Cn1KeP6U+f0p7/pT+/Cn3wSWtp1C/PuXBNxzYU+Lzp6TnT8nPn0LPn1KeP6U+f0p7/pT+/CkPsJXWyWl8d8rtBzqv729zu3hxXsK3yz96O7zV5eNrL59ee/n82svTay9fXnv5+trLtw0v3/PN5ftrLz9eevn7qVFj5a2R2/U8cj8Lij8lPX9Kfv4Uev6U8vwp9flT2tOn3H8zyp8ynj7l/rvGtDJequ36hrn/UpA/JT1/Sn7+FHr+lPL8KfX5U+6OfmrLN37SuPlU3n9nw58ynj7lfowHf0p8/pT0/Cn5yVNOv5VvR96/08b5OcjFZJk+Q1Lv32n8KfT8KeX5U+rzp7TnT+nPnzKePuX+ncafEp8/5fnR78+Pfn9+9Pvzo9+fH/3+/Oj350e/Pz/6998+jbpuAxBCujkn/o5z0u84J/+Oc+h3nFN+xzn12XNOv9WPBz73H1qdHp4tp46LvyJbnqq0j1PvL6MjrWHNo15Fw//n9Ov/+dPff/7Tn3/56VtK87f/9V+//mUJbT79+s//+7flf1linf/299/+8tNf//X3n74FPJ+znb/dKunUxaYS/vjxgOi/Ujj9Fscfv/2p88f/GH5MqXz7NX78Wk+/9vNj6m/H5PBjLuenXx+ntR9zWp85ff6n8mMO69Okj/9U44+1Lpc+PdIccV1avpVSxo91LWT0H0/P5s6Wf/tvsZ2KOVv58Z9O9Z2u8p+TTf8P",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
@@ -1942,6 +1810,26 @@
       ],
       "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAC/+mHCcz+jq407ZQQ8iqK5WhEMG6ovg0czCiBIj1ZsBAQbzkUDTFplayjWuZYPsnFCPRaOYYEkKPCA93zGNZqsO3XBVVHH6wKsNPAsZQwIp/s64o1GsqOkTNiXwIs4YASBwBhVsl3n0sg6EOPVWSnF4jt9fOmlTz0s2DABufzb0HzGPgZ5Pfj4HifLCZGK2Sm668x8RE89Eq482+lGCHKgb0kZOvqyCiYTW0bM+0OTRpgePrC5NqlNbxxGgEP+0ISHolbsvZMVt4xY3VUp+qvAuVGKCriPRsu+D/kCX105yG1CnJdhoQthJX0PlJvLF7GzIAsBhw0fuJg+UtIL2g7QYLs7EOR6ojrj1mYM92bQDk8/hVVaxwLS8wwXGG4VdcRJu2IDrEhAUW69OO8JWttGSUS6Q4cW+4XTJEBDUo/59HetEvAS76gaBj2SczkhcZ1BJx21QeGb+CsSctx6csP4tKvvdL+AX6P8NY6Nw8iSYMvDe70jTr4HGZTjLdZqNLARWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQNVrvvFHJ4/cBX+aM22YTQoACAzY80ug43VGwQJmXI/ikfu+C39vKCPVRpz5gaHvEfPq7YcmAmIR0u4Pg+MuRTDgg7wWfAtBKHji2ULCv/c05LrlCLSIxN9I5dVnSVOFQmDgAKuBstdDzJ79r8JkgT2OkB/rMf6AKfjVaq55xB1BalfgL38DiZ3P2ns6fmcitKymmYy9cDrvV3ucpWimGkARlSkEJmoeoLxg/jYyT2H59juNUVcLPfSOv4R7fT0H8L8tk8RlWiMnZAHemXBl5+Bn3K7Ey/nwDDDvP12aZ7hgZXScNkI75sewVh9PzCUKT5vUC4zboBHeMLUiMq2WJyFt3+AyJ+MXFmmpHrNNKl8vhUM8nfIW92qMPTAIk82UIQCuVmjiaymVN1HdMxvZ7Xjt4a4Omx+x4wiqKm12m7ISgIAYOm6QgjwN6FUyQ0lloFPZTTmk0JJbtMFBBJ0mCGCjQ6kiLRkmWI6g8/bqYfT1al6pOubTRN53bFoyqsAPAQ9+OpFBLgqm9xzkvy6iA11eTrJaPN9KQfjy0X0TH+rSTZrig6oSdZJ1c4EEaTlUxB2GQK+UcrddTJPRWkv2L2KMHxZJWFYl7SKzKxfhOVUn1YavbWuKUuDfxvH+Qe8MEmv8uKIaC7ORIPPA9FrJpx7X2S0mJthwVO5A0rUrcdVyIYWoEvf5koprAOXkR0LR6alaT61+Pk0tUmhsBeCZRSLzdFITilpbW0AoY0lFyk1zvfrtZMnu+vTBFqKep1dSYqeGer49xEp6iUpaO6FCmXAZ0LAvjJ42pqPK14nmnXKgI4jbchsl/s8rYIQHXHunWrZKwZp8gAi7yTzjEPIRjyJRaOlbaNBtl5YltO1sTZ94VvztRTH5ghpm+8rNBIEEsCj2dWiH+WmKFNu4lJJhB7pe1we+4gx/HQcPdPyA+UmSLJpo14r1NR4PetUffyN08H3MSJpEbVduBIaW70x4O0GG7M1IbR+RaBn3bQKXBGWx/7BOOi+2x3BRghS+vliS0MmKU6bx9pq2brnBbFtSPRKIywXOciI5/4CUHhD6941x3PwOJrBzlqT0lucGJIzsL+5ksxMjovCejng3dzgoANGjXlt4y+f48bVHZvm45ogRfVnCgHHm5tS5bMrtZjSmcG7+NyQCekPk5NcUExeWLzBjixYNSDoKhFmVLpFILPWSNR2x/MyXAF40tuleb7Qwf1OSSdgG2N7LW9x7kjw5SZHXLYXjLGNm5/cRN104IC5OwuC+YJBM8Q+sNBmvHqnG8KhQGeElJpkxLL1exqI7KEqbNSfNLr/2KyRaBKqyWPkhu6Gm5J8LpmZD6LMv0JDgC17ucjNkMMP+t9pri1fhVRALNOAIK8Wu2BmoG7NnRMTWEsgPyRommqqql1yEyOWNYAE66jvMCEHsbZSyhfG+u+uWng8seFYnDcX9osXTmdzALZ8EZe9LKxFtS4hiU0TyZxeCqTNyqtNpUwrkt1wivbJl8McFNuwC98m+TOGcKdJumDmULXKSAUH+vasH5MIMMngHpPeyPZzByGXvmTCZk6M56MuMZI0Hw03ctO9EUngwy/nW4Lb6pgndvVgX9dELxP2BDHgdeyOaR6CGNhaG7cAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiRZjLLFScfOsLo060OJsUxIajUo55Ebv4B17xLfkBNjDo22o+66BFRahR/4atgmh60oBZOk38fDhMoPZPUoOqQAxDcm91tv2g3iLODg36trzHoF/5WpayiUJMX3M2cNli+bbgtOLAGWjeXDJIKqfR0KCdcXjsk7rXhY+W5k8LSNHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
     },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "ZY5bCoMwEEX3Mt/5MFotuhUpEnWUQEgkj0IJ2XsnIjTUn8vc4XA5EVacwz5JvRkHwxhBmUV4aTS1mBjMViol96l8Q5WDNyfvDqFzdV5YDwNv+rpjgHo9766njU0qpFY3id14wi/6wfmPbZ/plai+hZViVnjZbEEvhZz/HPjneViz4BosZuNClnLkLasrmqXpLw==",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
     {
       "name": "verify_private_authwit",
       "is_unconstrained": false,
@@ -3574,7 +3462,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
@@ -3585,39 +3473,124 @@
         "directive_integer_quotient"
       ],
       "verification_key": "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"
+    },
+    {
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16775516380094354375": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 40
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "_log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "_recipient",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/+Wc6XLbNhDHKZu0TcmyZPmK3Svp3bRpKYnU0dNt0/u+lM+KYz8HHyPta7Rf2qer/jFXWsHojDteTPxPMMOhpYV2f1wuARBYuBadl8nsqFV/x9V5vTrj+060XKTucXXOrla6hrqyUIw1AsYVAsZVAsaYgDEhYFwjYFwnYNwgYEwJGOsEjA0Cxk0CxiYB4xYBY4uAsU3AuB2AMQRnh4Rzx5BTj+1D8e5G1z9G9wgY9wkYDwgYbxAwHhIwHhEwPkPA+CwB43MEjM8TML5AwHiTgPEWAeOLBIwvETC+TMD4CgHjqwSMrxEwvk7A+AYB420CxjcJGN8iYLxDwPg2AeM7BIwZAWOXgLFHwNgnYMwJGAsCxgEB45CAcUTAOCZgfJeA8T0CxvcJGD8gYPyQgPEjAsZjAsaPCRg/IWD8lIDxLgHjZwSMnxMwfkHA+CUB41cEjF8TMH5DwPgtAeN3BIzfEzD+QMD4IwHjTwSMPxMw/hKAMQTnryScv5FwTgJxRvcc6JXZgY1b2BiFjUfY2IONM9iYgo0f2FiBjQvYGIDEeyS2I3G8PTuQ+IykYiTsIgkWSaZI4kSSJJIQkeSHJDokqSEJDElWSGJCktDN2XFrdiCJBEkaSIJAkgEW8bFIjkVoLPJiERWLlFgExCIbFrGwSISrwiIHFhEwSY9JcEwyYxIXk6SYhMQkHybRMEmFSSBMsmASQyYJ8JKLl0i8pOElCC8ZGMRjkIxBKAZ5GERhkIJBADpZdGLoJNAIo5FDI4KHFA8AgmsS/XeRIPmnOqfVeUXJDTfRdVPHrqX+UTa+n3quz5C/n1Y6N4LoL4aiPw3Dn8lG27vlQr++FrG7Wp0n5cKXk3KZSeo8VHUeOnXkesLc7zwP669ur+n4KFLXIrbrYWz3a449fV+0TOzXo5Cxeb4pWdsTHtc/0nY0pU654Kk5sri8eB0iS5RM7i/s3Fb13NjacGTCgiLx21S+kXKvksk9jZVOu3gtRmHjNc8eX7zm3ScxXmNHFpcXr+P/xquOLTdek2hRpC0V2ZqS/e7I1pXsj3Jhu1Acg+rvsG3yeR+snz3rPmzHw69toayXC39IDK6q7xLlv0f+0fUdWapkcblsp159jpUdrUs4Eqd+Xn1uVec19Rv5fdtjf82xv8Tt+c71S+qpn3rqI9buVH83qgMx9Jf8Jrr47OI4rj5nVyrDwtdO2ukfdH1toaH+U9HfCKK/l4n+zTD8836qGeb+DkT/Vhj+efy0wvD3RH87DP+Z6N8Owz9/j+kE0V/Mx+U7Yfjn8b8bxv9z/r0w/HP9+2H45/f3IIz+sYw7bkSL4o4zD9X3dv1/b3zZcabYrzusocaZhw6P6x89zoTsyMPa9sjcZ/TIY+fIY8ena9NQ14Ghrm1DXQ1DXfuGutqGuuqGuvYMdbUMdaWGuizvo6W/LGN111CXZaxuGeq6ru2E5fNo6fvrGqsbhrosY8IyVi39tWOoy7KNthwDNA11WfYdls/QdY2vp6H9CtEPhV0PzDLfPFhkp987D2aoPxNfS6zquW9tU64vcer/6fh5M4ife1N5J5M2SPvCN1dlabvm2Isi//us2G96eIS77pFd5R/Mno5OTsf383wwzIuifzKsOfqF1f1OzzvrPkfX970b++bVDH098q3xtJRfUWIl23JkiZIJo17j8c07WvJfxv/aftsjc8del72XnWg51vTz2IgWz3Bc2l/7cHTeljxirPQn0fIabuTYT5z6f1ef3bbuqs/I2XDaPetPz6bF9MGD/GTacfRrH8JP/wJJ9PoyCV0AAA==",
+      "debug_symbols": "tZbRCsIgGIXfxWsvpm7+1qtEhNtcCOKG24IYe/c0oqKuz83YkV8/L/zgbKx37Xq9+DiMMzueNhbGzi5+jDltO2dt8iH46+V7mVXlIxr93DBPNpY8LzYt7CiUNIYzF/vyr5TJhww+uJyk2vnfPMnXMNF7sqb9zDOA0ACDBhzAAF2hAQINkGiAQgNqNKBBA9Ama7TJGm2yRptMaJMJbTKhTSa0yYQ2mdAmE9pkQptMUJP3nG42edsG92o4wxq7r8Kz3Cf3032mNHauX5MrLehTgMprrCVvZLl2sVeYigvTZEgGPQA=",
+      "brillig_names": [
+        "process_log"
+      ]
     }
   ],
   "outputs": {
     "globals": {},
     "structs": {
       "functions": [
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "inner_hash",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrSingleKeyAccount::verify_private_authwit_parameters"
-              }
-            },
-            {
-              "name": "return_type",
-              "type": {
-                "kind": "field"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrSingleKeyAccount::verify_private_authwit_abi"
-        },
         {
           "fields": [
             {
@@ -3800,47 +3773,70 @@
           ],
           "kind": "struct",
           "path": "SchnorrSingleKeyAccount::entrypoint_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "inner_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "SchnorrSingleKeyAccount::verify_private_authwit_parameters"
+              }
+            },
+            {
+              "name": "return_type",
+              "type": {
+                "kind": "field"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "SchnorrSingleKeyAccount::verify_private_authwit_abi"
         }
       ]
     }
   },
   "file_map": {
-    "101": {
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
-    },
-    "129": {
+    "122": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/functions/utils.nr",
       "source": "use crate::macros::{\n    functions::{abi_export::create_fn_abi_export, call_interface_stubs::stub_fn, stub_registry},\n    notes::NOTES,\n    utils::{\n        add_to_hasher, fn_has_noinitcheck, get_fn_visibility, is_fn_initializer, is_fn_internal,\n        is_fn_private, is_fn_view, modify_fn_body, module_has_initializer, module_has_storage,\n    },\n};\nuse protocol_types::meta::generate_serialize_to_fields;\nuse std::meta::type_of;\n\npub(crate) comptime fn transform_private(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[private] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Private functions undergo a lot of transformations from their Aztec.nr form into a circuit that can be fed to the\n    // Private Kernel Circuit.\n    // First we change the function signature so that it also receives `PrivateContextInputs`, which contain information\n    // about the execution context (e.g. the caller).\n    let original_params = f.parameters();\n    f.set_parameters(&[(\n        quote { inputs },\n        quote { crate::context::inputs::private_context_inputs::PrivateContextInputs }.as_type(),\n    )]\n        .append(original_params));\n\n    let mut body = f.body().as_block().unwrap();\n\n    // The original params are hashed and passed to the `context` object, so that the kernel can verify we've received\n    // the correct values.\n    // TODO: Optimize args_hasher for small number of arguments\n    let args_hasher_name = quote { args_hasher };\n    let args_hasher = original_params.fold(\n        quote {\n            let mut $args_hasher_name = dep::aztec::hash::ArgsHasher::new();\n        },\n        |args_hasher, param: (Quoted, Type)| {\n            let (name, typ) = param;\n            let appended_arg = add_to_hasher(args_hasher_name, name, typ);\n            quote {\n                $args_hasher\n                $appended_arg\n            }\n        },\n    );\n\n    let context_creation = quote {\n        let mut context = dep::aztec::context::private_context::PrivateContext::new(inputs, dep::aztec::protocol_types::traits::Hash::hash($args_hasher_name));\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !is_fn_initializer(f) & !fn_has_noinitcheck(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    // All private functions perform note discovery, since they may need to access notes. This is slightly inefficient\n    // and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    // Finally, we need to change the return type to be `PrivateCircuitPublicInputs`, which is what the Private Kernel\n    // circuit expects.\n    let return_value_var_name = quote { macro__returned__values };\n\n    let return_value_type = f.return_type();\n    let return_value = if body.len() == 0 {\n        quote {}\n    } else if return_value_type != type_of(()) {\n        // The original return value is passed to a second args hasher which the context receives.\n        let (body_without_return, last_body_expr) = body.pop_back();\n        let return_value = last_body_expr.quoted();\n        let return_value_assignment =\n            quote { let $return_value_var_name: $return_value_type = $return_value; };\n        let return_hasher_name = quote { return_hasher };\n        let return_value_into_hasher =\n            add_to_hasher(return_hasher_name, return_value_var_name, return_value_type);\n\n        body = body_without_return;\n\n        quote {\n            let mut $return_hasher_name = dep::aztec::hash::ArgsHasher::new();\n            $return_value_assignment\n            $return_value_into_hasher\n            context.set_return_hash($return_hasher_name);\n        }\n    } else {\n        let (body_without_return, last_body_expr) = body.pop_back();\n        if !last_body_expr.has_semicolon()\n            & last_body_expr.as_for().is_none()\n            & last_body_expr.as_assert().is_none()\n            & last_body_expr.as_for_range().is_none()\n            & last_body_expr.as_assert_eq().is_none()\n            & last_body_expr.as_let().is_none() {\n            let unused_return_value_name = f\"_{return_value_var_name}\".quoted_contents();\n            body = body_without_return.push_back(\n                quote { let $unused_return_value_name = $last_body_expr; }.as_expr().unwrap(),\n            );\n        }\n        quote {}\n    };\n\n    let context_finish = quote { context.finish() };\n\n    let to_prepend = quote {\n        $args_hasher\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n        $note_discovery_call\n    };\n\n    let to_append = quote {\n        $return_value\n        $mark_as_initialized\n        $context_finish\n    };\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n    f.set_return_type(\n        quote { dep::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs }\n            .as_type(),\n    );\n    f.set_return_data();\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_public(f: FunctionDefinition) -> Quoted {\n    let fn_abi = create_fn_abi_export(f);\n    let fn_stub = stub_fn(f);\n    stub_registry::register(f.module(), fn_stub);\n\n    // If a function is further modified as unconstrained, we throw an error\n    if f.is_unconstrained() {\n        let name = f.name();\n        panic(\n            f\"Function {name} is annotated with #[public] but marked as unconstrained, remove unconstrained keyword\",\n        );\n    }\n\n    let module_has_initializer = module_has_initializer(f.module());\n    let module_has_storage = module_has_storage(f.module());\n\n    // Public functions undergo a lot of transformations from their Aztec.nr form.\n    let original_params = f.parameters();\n    let args_len = original_params\n        .map(|(name, typ): (Quoted, Type)| {\n            generate_serialize_to_fields(name, typ, &[], false).0.len()\n        })\n        .fold(0, |acc: u32, val: u32| acc + val);\n\n    // Unlike in the private case, in public the `context` does not need to receive the hash of the original params.\n    let context_creation = quote {\n        let mut context = dep::aztec::context::public_context::PublicContext::new(|| {\n        // We start from 1 because we skip the selector for the dispatch function.\n        let serialized_args : [Field; $args_len] = dep::aztec::context::public_context::calldata_copy(1, $args_len);\n        dep::aztec::hash::hash_args_array(serialized_args)\n        });\n    };\n\n    // Modifications introduced by the different marker attributes.\n    let internal_check = if is_fn_internal(f) {\n        create_internal_check(f)\n    } else {\n        quote {}\n    };\n\n    let view_check = if is_fn_view(f) {\n        create_view_check(f)\n    } else {\n        quote {}\n    };\n\n    let (assert_initializer, mark_as_initialized) = if is_fn_initializer(f) {\n        (create_assert_correct_initializer_args(f), create_mark_as_initialized(f))\n    } else {\n        (quote {}, quote {})\n    };\n\n    let storage_init = if module_has_storage {\n        // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n        // referenced. We instead ignore 'unused variable' warnings for it.\n        quote {\n            #[allow(unused_variables)]\n            let storage = Storage::init(&mut context);\n        }\n    } else {\n        quote {}\n    };\n\n    // Initialization checks are not included in contracts that don't have initializers.\n    let init_check = if module_has_initializer & !fn_has_noinitcheck(f) & !is_fn_initializer(f) {\n        create_init_check(f)\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $assert_initializer\n        $init_check\n        $internal_check\n        $view_check\n        $storage_init\n    };\n\n    let to_append = quote {\n        $mark_as_initialized\n    };\n\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, to_append);\n    f.set_body(modified_body);\n\n    // All public functions are automatically made unconstrained, even if they were not marked as such. This is because\n    // instead of compiling into a circuit, they will compile to bytecode that will be later transpiled into AVM\n    // bytecode.\n    f.set_unconstrained(true);\n    f.set_return_public(true);\n\n    fn_abi\n}\n\npub(crate) comptime fn transform_unconstrained(f: FunctionDefinition) {\n    let context_creation = quote { let mut context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new(); };\n    let module_has_storage = module_has_storage(f.module());\n\n    let storage_init = if module_has_storage {\n        quote {\n            // Some functions don't access storage, but it'd be quite difficult to only inject this variable if it is\n            // referenced. We instead ignore 'unused variable' warnings for it.\n            #[allow(unused_variables)]\n            let storage = Storage::init(context);\n        }\n    } else {\n        quote {}\n    };\n\n    // All unconstrained functions perform note discovery, since they may need to access notes. This is slightly\n    // inefficient and could be improved by only doing it once we actually attempt to read any.\n    let note_discovery_call = if NOTES.len() > 0 {\n        create_note_discovery_call()\n    } else {\n        quote {}\n    };\n\n    let to_prepend = quote {\n        $context_creation\n        $storage_init\n        $note_discovery_call\n    };\n    let body = f.body().as_block().unwrap();\n    let modified_body = modify_fn_body(body, to_prepend, quote {});\n    f.set_return_public(true);\n    f.set_body(modified_body);\n}\n\ncomptime fn create_internal_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called internally\";\n    quote { assert(context.msg_sender() == context.this_address(), $assertion_message); }\n}\n\ncomptime fn create_view_check(f: FunctionDefinition) -> Quoted {\n    let name = f.name();\n    let assertion_message = f\"Function {name} can only be called statically\";\n    if is_fn_private(f) {\n        // Here `context` is of type context::PrivateContext\n        quote { assert(context.inputs.call_context.is_static_call == true, $assertion_message); }\n    } else {\n        // Here `context` is of type context::PublicContext\n        quote { assert(context.is_static_call(), $assertion_message); }\n    }\n}\n\ncomptime fn create_assert_correct_initializer_args(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_initialization_matches_address_preimage_{fn_visibility}(context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_mark_as_initialized(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::mark_as_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\ncomptime fn create_init_check(f: FunctionDefinition) -> Quoted {\n    let fn_visibility = get_fn_visibility(f);\n    f\"dep::aztec::macros::functions::initialization_utils::assert_is_initialized_{fn_visibility}(&mut context);\"\n        .quoted_contents()\n}\n\n/// Injects a call to `aztec::discovery::discover_new_notes`, causing for new notes to be added to PXE and made\n/// available for the current execution.\ncomptime fn create_note_discovery_call() -> Quoted {\n    quote {\n        /// Safety: note discovery returns nothing and is performed solely for its side-effects. It is therefore always\n        /// safe to call.\n        unsafe {\n            dep::aztec::discovery::discover_new_notes(\n                context.this_address(),\n                _compute_note_hash_and_nullifier,\n            )\n        };\n    }\n}\n"
     },
-    "130": {
+    "123": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/macros/mod.nr",
       "source": "pub mod dispatch;\npub mod functions;\npub mod utils;\npub mod notes;\npub mod storage;\npub mod events;\n\nuse functions::{stub_registry, utils::transform_unconstrained};\nuse notes::{generate_note_export, NOTES};\nuse storage::STORAGE_LAYOUT_NAME;\n\nuse dispatch::generate_public_dispatch;\nuse utils::{get_trait_impl_method, module_has_storage};\n\nuse crate::discovery::MAX_NOTE_PACKED_LEN;\n\n/// Marks a contract as an Aztec contract, generating the interfaces for its functions and notes, as well as injecting\n/// the `process_log` and `sync_notes` functions PXE requires in order to discover notes.\n/// Note: This is a module annotation, so the returned quote gets injected inside the module (contract) itself.\npub comptime fn aztec(m: Module) -> Quoted {\n    let interface = generate_contract_interface(m);\n    let unconstrained_functions = m.functions().filter(|f: FunctionDefinition| {\n        f.is_unconstrained() & !f.has_named_attribute(\"test\") & !f.has_named_attribute(\"public\")\n    });\n    for f in unconstrained_functions {\n        transform_unconstrained(f);\n    }\n\n    let contract_library_method_compute_note_hash_and_nullifier =\n        generate_contract_library_method_compute_note_hash_and_nullifier();\n    let process_log = generate_process_log();\n    let note_exports = generate_note_exports();\n    let public_dispatch = generate_public_dispatch(m);\n    let sync_notes = generate_sync_notes();\n\n    quote {\n        $note_exports\n        $interface\n        $contract_library_method_compute_note_hash_and_nullifier\n        $process_log\n        $public_dispatch\n        $sync_notes\n    }\n}\n\ncomptime fn generate_contract_interface(m: Module) -> Quoted {\n    let module_name = m.name();\n    let contract_stubs = stub_registry::get(m);\n    let fn_stubs_quote = if contract_stubs.is_some() {\n        contract_stubs.unwrap().join(quote {})\n    } else {\n        quote {}\n    };\n\n    let has_storage_layout = module_has_storage(m) & STORAGE_LAYOUT_NAME.get(m).is_some();\n    let storage_layout_getter = if has_storage_layout {\n        let storage_layout_name = STORAGE_LAYOUT_NAME.get(m).unwrap();\n        quote {\n            pub fn storage_layout() -> StorageLayoutFields {\n                $storage_layout_name.fields\n            }\n        }\n    } else {\n        quote {}\n    };\n\n    let library_storage_layout_getter = if has_storage_layout {\n        quote {\n            #[contract_library_method]\n            $storage_layout_getter\n        }\n    } else {\n        quote {}\n    };\n\n    quote {\n        pub struct $module_name {\n            pub target_contract: dep::aztec::protocol_types::address::AztecAddress\n        }\n\n        impl $module_name {\n            $fn_stubs_quote\n\n            pub fn at(\n                addr: aztec::protocol_types::address::AztecAddress\n            ) -> Self {\n                Self { target_contract: addr }\n            }\n\n            pub fn interface() -> Self {\n                Self { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n            }\n\n            $storage_layout_getter\n        }\n\n        #[contract_library_method]\n        pub fn at(\n            addr: aztec::protocol_types::address::AztecAddress\n        ) -> $module_name {\n            $module_name { target_contract: addr }\n        }\n\n        #[contract_library_method]\n        pub fn interface() -> $module_name {\n            $module_name { target_contract: aztec::protocol_types::address::AztecAddress::zero() }\n        }\n\n        $library_storage_layout_getter\n\n    }\n}\n\n/// Generates a contract library method called `_compute_note_hash_and_nullifier` which is used for note\n/// discovery (to create the `aztec::discovery::ComputeNoteHashAndNullifier` function) and to implement the\n/// `compute_note_hash_and_nullifier` unconstrained contract function.\ncomptime fn generate_contract_library_method_compute_note_hash_and_nullifier() -> Quoted {\n    let notes = NOTES.entries();\n\n    let mut max_note_packed_len: u32 = 0;\n    if notes.len() > 0 {\n        max_note_packed_len = notes.fold(\n            0,\n            |acc, (_, (_, len, _, _)): (Type, (StructDefinition, u32, Field, [(Quoted, u32, bool)]))| {\n                if len > acc {\n                    len\n                } else {\n                    acc\n                }\n            },\n        );\n\n        if max_note_packed_len > MAX_NOTE_PACKED_LEN {\n            panic(\n                f\"One of the notes has packed len {max_note_packed_len} but the maximum is {MAX_NOTE_PACKED_LEN}\",\n            );\n        }\n\n        // Contracts that do define notes produce an if-else chain where `note_type_id` is matched against the\n        // `get_note_type_id()` function of each note type that we know of, in order to identify the note type. Once we\n        // know it we call we correct `unpack` method from the `Packable` trait to obtain the underlying note type, and\n        // compute the note hash (non-siloed) and inner nullifier (also non-siloed).\n\n        let mut if_note_type_id_match_statements_list = &[];\n        for i in 0..notes.len() {\n            let (typ, (_, packed_note_length, _, _)) = notes[i];\n\n            let get_note_type_id = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteType },\n                quote { get_id },\n            );\n            let unpack = get_trait_impl_method(\n                typ,\n                quote { crate::protocol_types::traits::Packable<_> },\n                quote { unpack },\n            );\n\n            let compute_note_hash = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_note_hash },\n            );\n\n            let compute_nullifier_unconstrained = get_trait_impl_method(\n                typ,\n                quote { crate::note::note_interface::NoteHash },\n                quote { compute_nullifier_unconstrained },\n            );\n\n            let if_or_else_if = if i == 0 {\n                quote { if }\n            } else {\n                quote { else if }\n            };\n\n            if_note_type_id_match_statements_list = if_note_type_id_match_statements_list.push_back(\n                quote {\n                    $if_or_else_if note_type_id == $get_note_type_id() {\n                        // As an extra safety check we make sure that the packed_note BoundedVec has the expected\n                        // length, since we're about to interpret it's raw storage as a fixed-size array by calling the\n                        // unpack function on it.\n                        let expected_len = $packed_note_length;\n                        let actual_len = packed_note.len();\n                        assert(\n                            actual_len == expected_len,\n                            f\"Expected packed note of length {expected_len} but got {actual_len} for note type id {note_type_id}\"\n                        );\n\n                        let note = $unpack(aztec::utils::array::subarray(packed_note.storage(), 0));\n\n                        let note_hash = $compute_note_hash(note, storage_slot);\n    \n                        // The note discovery process finds settled notes, that is, notes that were created in prior\n                        // transactions and are therefore already part of the note hash tree. We therefore compute the\n                        // nullification note hash by treating the note as a settled note with the provided nonce.\n                        let note_hash_for_nullify = aztec::note::utils::compute_note_hash_for_nullify(\n                            aztec::note::retrieved_note::RetrievedNote{ \n                                note, \n                                contract_address, \n                                metadata: aztec::note::note_metadata::SettledNoteMetadata::new(nonce).into() \n                            }, \n                            storage_slot,\n                        );\n\n                        let inner_nullifier = $compute_nullifier_unconstrained(note, note_hash_for_nullify);\n\n                        Option::some(\n                            aztec::discovery::NoteHashAndNullifier {\n                                note_hash, inner_nullifier\n                            }\n                        )\n                    }\n                },\n            );\n        }\n\n        let if_note_type_id_match_statements = if_note_type_id_match_statements_list.join(quote {});\n\n        quote {\n            /// Unpacks an array into a note corresponding to `note_type_id` and then computes its note hash\n            /// (non-siloed) and inner nullifier (non-siloed) assuming the note has been inserted into the note hash\n            /// tree with `nonce`.\n            ///\n            /// The signature of this function notably matches the `aztec::discovery::ComputeNoteHashAndNullifier` type,\n            /// and so it can be used to call functions from that module such as `discover_new_notes`, `do_process_log`\n            /// and `process_private_note_log`.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                storage_slot: Field,\n                note_type_id: Field,\n                contract_address: aztec::protocol_types::address::AztecAddress,\n                nonce: Field,\n            ) -> Option<aztec::discovery::NoteHashAndNullifier> {\n                $if_note_type_id_match_statements\n                else {\n                    Option::none()\n                }\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            /// This contract does not use private notes, so this function should never be called as it will\n            /// unconditionally fail.\n            ///\n            /// This function is automatically injected by the `#[aztec]` macro.\n            #[contract_library_method]\n            unconstrained fn _compute_note_hash_and_nullifier(\n                _packed_note: BoundedVec<Field, aztec::discovery::MAX_NOTE_PACKED_LEN>,\n                _storage_slot: Field,\n                _note_type_id: Field,\n                _contract_address: aztec::protocol_types::address::AztecAddress,\n            ) -> pub Option<aztec::discovery::NoteHashAndNullifier> {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_process_log() -> Quoted {\n    // This mandatory function processes a log emitted by the contract. This is currently used to process private logs\n    // and perform note discovery of either private notes or partial notes.\n    // The bulk of the work of this function is done by aztec::discovery::do_process_log, so all we need to do is call\n    // that function.\n\n    // We'll produce the entire body of the function in one go and then insert it into the function.\n    let notes = NOTES.entries();\n\n    if notes.len() > 0 {\n        quote {\n            unconstrained fn process_log(\n                log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                tx_hash: Field,\n                unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                first_nullifier_in_tx: Field,\n                recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                // Because this unconstrained function is injected after the contract is processed by the macros, it'll not\n                // be modified by the macros that alter unconstrained functions. As such, we need to manually inject the\n                // unconstrained execution context since it will not be available otherwise.\n                let context = dep::aztec::context::unconstrained_context::UnconstrainedContext::new();\n\n                // TODO(#10727): allow other contracts to process logs and deliver notes\n                let contract_address = context.this_address();\n\n                aztec::discovery::private_logs::do_process_log(\n                    contract_address,\n                    log_plaintext,\n                    tx_hash,\n                    unique_note_hashes_in_tx,\n                    first_nullifier_in_tx,\n                    recipient,\n                    _compute_note_hash_and_nullifier,\n                );\n            }\n        }\n    } else {\n        // Contracts with no notes still implement this function to avoid having special-casing, the implementation\n        // simply throws immediately.\n        quote {\n            unconstrained fn process_log(\n                _log_plaintext: BoundedVec<Field, dep::aztec::protocol_types::constants::PRIVATE_LOG_SIZE_IN_FIELDS>,\n                _tx_hash: Field,\n                _unique_note_hashes_in_tx: BoundedVec<Field, dep::aztec::protocol_types::constants::MAX_NOTE_HASHES_PER_TX>,\n                _first_nullifier_in_tx: Field,\n                _recipient: aztec::protocol_types::address::AztecAddress,\n            ) {\n                panic(f\"This contract does not use private notes\")\n            }\n        }\n    }\n}\n\ncomptime fn generate_note_exports() -> Quoted {\n    let notes = NOTES.values();\n    // Second value in each tuple is `note_packed_len` and that is ignored here because it's only used when\n    // generating partial note helper functions.\n    notes\n        .map(|(s, _, note_type_id, fields): (StructDefinition, u32, Field, [(Quoted, u32, bool)])| {\n            generate_note_export(s, note_type_id, fields)\n        })\n        .join(quote {})\n}\n\ncomptime fn generate_sync_notes() -> Quoted {\n    quote {\n        unconstrained fn sync_notes() {\n            aztec::oracle::note_discovery::sync_notes();\n        }\n    }\n}\n"
     },
-    "150": {
+    "143": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "152": {
+    "145": {
       "path": "/home/aztec-dev/aztec-packages/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    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "154": {
+    "147": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
       "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n    let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "16": {
-      "path": "std/embedded_curve_ops.nr",
-      "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\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\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\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 = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    let point_array = multi_scalar_mul_array_return(points, scalars);\n    EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    multi_scalar_mul([g1], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    let x_coordinates_match = point1.x == point2.x;\n    let y_coordinates_match = point1.y == point2.y;\n    let double_predicate = (x_coordinates_match & y_coordinates_match);\n    let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n    let point1_1 = EmbeddedCurvePoint {\n        x: point1.x + (x_coordinates_match as Field),\n        y: point1.y,\n        is_infinite: x_coordinates_match,\n    };\n    // point1_1 is guaranteed to have a different abscissa than point2\n    let mut result = embedded_curve_add_unsafe(point1_1, point2);\n    result.is_infinite = x_coordinates_match;\n\n    // dbl if x_match, y_match\n    let double = embedded_curve_add_unsafe(point1, point1);\n    result = if double_predicate { double } else { result };\n\n    // infinity if x_match, !y_match\n    if point1.is_infinite {\n        result = point2;\n    }\n    if point2.is_infinite {\n        result = point1;\n    }\n    let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n    result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n    result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    let point_array = embedded_curve_add_array_return(point1, point2);\n    let x = point_array[0];\n    let y = point_array[1];\n\n    EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n"
-    },
-    "164": {
+    "157": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/note_discovery.nr",
       "source": "use crate::discovery::MAX_NOTE_PACKED_LEN;\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS},\n};\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them\n/// available for later querying via the `get_notes` oracle.\npub unconstrained fn sync_notes() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n\n/// Informs PXE of a note's existence so that it can later be retrieved by the `getNotes` oracle. The note will be\n/// scoped to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The packed note is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value\n/// is typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are\n/// the inner hashes, i.e. the raw hashes returned by `NoteHash::compute_note_hash` and\n/// `NoteHash::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree\n/// at `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was successfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {\n    deliver_note_oracle(\n        contract_address,\n        storage_slot,\n        nonce,\n        packed_note,\n        note_hash,\n        nullifier,\n        tx_hash,\n        recipient,\n    )\n}\n\n/// The contents of a public log, plus contextual information about the transaction in which the log was emitted. This\n/// is the data required in order to discover notes that are being delivered in a log.\n// TODO(#11639): this could also be used to fetch private logs, but the `BoundedVec` maximum length is that of a public\n// log.\npub struct LogWithTxData {\n    pub log_content: BoundedVec<Field, PUBLIC_LOG_DATA_SIZE_IN_FIELDS>,\n    pub tx_hash: Field,\n    /// The array of new note hashes created by `tx_hash`\n    pub unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    /// The first nullifier created by `tx_hash`\n    pub first_nullifier_in_tx: Field,\n}\n\n/// Fetches a log from the node that has the corresponding `tag`. The log can be either a public or a private log, and\n/// the tag is the first field in the log's content. Returns `Option::none` if no such log exists. Throws if more than\n/// one log with that tag exists.\n/// Public logs have an extra field included at the beginning with the address of the contract that emtitted them.\n// TODO(#11627): handle multiple logs with the same tag.\n// TODO(#10273): improve contract siloing of logs, don't introduce an extra field.\npub unconstrained fn get_log_by_tag(tag: Field) -> Option<LogWithTxData> {\n    get_log_by_tag_oracle(tag)\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    packed_note: BoundedVec<Field, MAX_NOTE_PACKED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {}\n\n#[oracle(getLogByTag)]\nunconstrained fn get_log_by_tag_oracle(tag: Field) -> Option<LogWithTxData> {}\n"
     },
-    "165": {
+    "158": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
       "source": "use crate::{\n    note::{note_interface::NoteType, note_metadata::NoteMetadata, retrieved_note::RetrievedNote},\n    utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    traits::{Deserialize, FromField, Packable},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(storage_slot, note_type_id, packed_note, note_hash, counter);\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<RetrievedNote<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 TODO(benesjan): try removing this.\n) -> [Option<RetrievedNote<Note>>; S]\nwhere\n    Note: NoteType + Packable<N>,\n{\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let maybe_nonce = fields[read_offset];\n            let maybe_note_hash_counter = fields[read_offset + 1] as u32;\n            let packed_note = array::subarray(fields, read_offset + 2);\n\n            let note = Note::unpack(packed_note);\n            let retrieved_note = RetrievedNote {\n                note,\n                contract_address,\n                metadata: NoteMetadata::from_raw_data(maybe_note_hash_counter != 0, maybe_nonce),\n            };\n\n            placeholder_opt_notes[i] = Option::some(retrieved_note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n"
     },
+    "16": {
+      "path": "std/embedded_curve_ops.nr",
+      "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\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\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\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 = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    let point_array = multi_scalar_mul_array_return(points, scalars);\n    EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    multi_scalar_mul([g1], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    let x_coordinates_match = point1.x == point2.x;\n    let y_coordinates_match = point1.y == point2.y;\n    let double_predicate = (x_coordinates_match & y_coordinates_match);\n    let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n    let point1_1 = EmbeddedCurvePoint {\n        x: point1.x + (x_coordinates_match as Field),\n        y: point1.y,\n        is_infinite: x_coordinates_match,\n    };\n    // point1_1 is guaranteed to have a different abscissa than point2\n    let mut result = embedded_curve_add_unsafe(point1_1, point2);\n    result.is_infinite = x_coordinates_match;\n\n    // dbl if x_match, y_match\n    let double = embedded_curve_add_unsafe(point1, point1);\n    result = if double_predicate { double } else { result };\n\n    // infinity if x_match, !y_match\n    if point1.is_infinite {\n        result = point2;\n    }\n    if point2.is_infinite {\n        result = point1;\n    }\n    let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n    result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n    result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    let point_array = embedded_curve_add_array_return(point1, point2);\n    let x = point_array[0];\n    let y = point_array[1];\n\n    EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n"
+    },
     "17": {
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
@@ -3849,89 +3845,93 @@
       "path": "std/field/mod.nr",
       "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        self.__assert_max_bit_size(BIT_SIZE);\n    }\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_le_bits)]\n    fn _to_le_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n    /// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n    /// wrap around due to overflow when verifying the decomposition.\n    #[builtin(to_be_bits)]\n    fn _to_be_bits<let N: u32>(self: Self) -> [u1; N] {}\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n    /// This slice will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_le_bits\n        let bits = self._to_le_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[u1; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting slice will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [u1; N] {\n        // docs:end:to_be_bits\n        let bits = self._to_be_bits();\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i] == 1);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    // docs:start:to_le_radix\n    pub fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        self.__to_le_radix(radix)\n    }\n    // docs:end:to_le_radix\n\n    // docs:start:to_be_radix\n    pub fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            crate::assert_constant(radix);\n        }\n        self.__to_be_radix(radix)\n    }\n    // docs:end:to_be_radix\n\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // `_radix` must be less than 256\n    #[builtin(to_be_radix)]\n    fn __to_be_radix<let N: u32>(self, radix: u32) -> [u8; N] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [u1; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime};\n    use super::field_less_than;\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_be_bits();\n        assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [u1; 8] = field.to_le_bits();\n        assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(f\"radix must be greater than 1\");\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n    //#[test]\n    //fn test_to_le_radix_brillig_1() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(1);\n    //        crate::println(out);\n    //        let expected = [0; 8];\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(f\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(f\"radix must be less than or equal to 256\")\n        }\n    }\n\n    // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n    //#[test]\n    //fn test_to_le_radix_brillig_512() {\n    //    // this test should only fail in constrained mode\n    //    if runtime::is_unconstrained() {\n    //        let field = 1;\n    //        let out: [u8; 8] = field.to_le_radix(512);\n    //        let mut expected = [0; 8];\n    //        expected[0] = 1;\n    //        assert(out == expected, \"unexpected result\");\n    //    }\n    //}\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n}\n"
     },
-    "194": {
+    "187": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "20": {
+    "19": {
       "path": "std/hash/mod.nr",
-      "source": "pub mod poseidon;\npub mod poseidon2;\npub mod keccak;\npub mod sha256;\npub mod sha512;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::uint128::U128;\n\n// Kept for backwards compatibility\npub use sha256::{digest, sha256, sha256_compression, sha256_var};\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n    let mut sum = 0;\n\n    for input in inputs {\n        let input_bytes: [u8; 32] = input.to_le_bytes();\n        sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n    }\n\n    sum\n}\n\n// docs:start:keccak256\npub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]\n// docs:end:keccak256\n{\n    crate::hash::keccak::keccak256(input, message_size)\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: StructDefinition) -> Quoted {\n    let name = quote { Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher<H>\nwhere\n    H: Hasher,\n{\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher<H> for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl Hash for U128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self.lo as Field);\n        H::write(state, self.hi as Field);\n    }\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
+      "source": "pub mod poseidon;\npub mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    // Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n    let mut sum = 0;\n\n    for input in inputs {\n        let input_bytes: [u8; 32] = input.to_le_bytes();\n        sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n    }\n\n    sum\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: StructDefinition) -> Quoted {\n    let name = quote { Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher<H>\nwhere\n    H: Hasher,\n{\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher<H> for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
     },
-    "25": {
+    "24": {
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "264": {
+    "257": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, GENERATOR_INDEX__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE,\n        MAX_PROTOCOL_CONTRACTS,\n    },\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_protocol_contract(self) -> bool {\n        self.inner.lt(MAX_PROTOCOL_CONTRACTS as Field)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "281": {
+    "274": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "282": {
+    "275": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        contract_class_log::ContractClassLog,\n        function_selector::FunctionSelector,\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH, TWO_POW_64,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, ToField},\n    utils::{\n        arrays::{array_concat, unsafe_padded_array_length},\n        field::{field_from_bytes, field_from_bytes_32_trunc},\n    },\n};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_field(\n    contract_address: AztecAddress,\n    first_field: Field,\n) -> Field {\n    poseidon2_hash([contract_address.to_field(), first_field])\n}\n\npub fn silo_contract_class_log(contract_class_log: ContractClassLog) -> ContractClassLog {\n    if contract_class_log.contract_address.is_zero() {\n        contract_class_log\n    } else {\n        let mut log = contract_class_log;\n        log.log.fields[0] = compute_siloed_contract_class_log_field(\n            contract_class_log.contract_address,\n            log.log.fields[0],\n        );\n        log\n    }\n}\n\npub fn compute_contract_class_log_hash(contract_class_log: ContractClassLog) -> Field {\n    let array = contract_class_log.log.fields;\n    // Safety: The below length is constrained in the base rollup.\n    let length = unsafe { unsafe_padded_array_length(array) };\n    if length == 0 {\n        0\n    } else {\n        poseidon2_hash(array)\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a u128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "299": {
+    "292": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "308": {
+    "301": {
       "path": "/home/aztec-dev/aztec-packages/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"
+      "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, ToField},\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"
     },
-    "357": {
+    "350": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "370": {
+    "363": {
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/schnorr/v0.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"
     },
-    "51": {
+    "47": {
       "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"
     },
-    "6": {
-      "path": "std/collections/bounded_vec.nr",
-      "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\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        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\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        }\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        static_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        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\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        }\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\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\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\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\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        use crate::convert::From;\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"
-    },
-    "61": {
+    "54": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/auth_oracle.nr",
-      "source": "use dep::authwit::auth_witness;\nuse dep::aztec::{\n    protocol_types::{address::PartialAddress, public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys}},\n    utils::array,\n};\n\npub struct AuthWitness {\n    keys: PublicKeys,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 77]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + PUBLIC_KEYS_LENGTH] as u8;\n        }\n        Self {\n            keys: PublicKeys::deserialize(array::subarray(values, 0)),\n            signature,\n            partial_address: PartialAddress::from_field(values[76]),\n        }\n    }\n}\n\npub unconstrained fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 77] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n"
+      "source": "use dep::authwit::auth_witness;\nuse dep::aztec::{\n    protocol_types::{address::PartialAddress, public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys}},\n    utils::array,\n};\nuse aztec::protocol_types::traits::Deserialize;\n\npub struct AuthWitness {\n    keys: PublicKeys,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 77]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + PUBLIC_KEYS_LENGTH] as u8;\n        }\n        Self {\n            keys: PublicKeys::deserialize(array::subarray(values, 0)),\n            signature,\n            partial_address: PartialAddress::from_field(values[76]),\n        }\n    }\n}\n\npub unconstrained fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 77] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n"
     },
-    "62": {
+    "55": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/main.nr",
       "source": "mod util;\nmod auth_oracle;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\npub contract SchnorrSingleKeyAccount {\n    use dep::aztec::prelude::PrivateContext;\n\n    use dep::authwit::{account::AccountActions, entrypoint::{app::AppPayload, fee::FeePayload}};\n\n    use crate::{auth_oracle::get_auth_witness, util::recover_address};\n\n    use dep::aztec::macros::functions::{private, view};\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts\n    #[private]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[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        // Safety: The witness is only used as a \"magical value\" that makes the signature verification\n        // in `recover_address` and the address check below pass. Hence it's safe.\n        let witness = unsafe { get_auth_witness(outer_hash) };\n        recover_address(outer_hash, witness).eq(context.this_address())\n    }\n}\n"
     },
-    "63": {
+    "56": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/util.nr",
       "source": "use crate::auth_oracle::AuthWitness;\nuse dep::aztec::prelude::AztecAddress;\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    let public_key = EmbeddedCurvePoint {\n        x: witness.keys.ivpk_m.inner.x,\n        y: witness.keys.ivpk_m.inner.y,\n        is_infinite: false,\n    };\n\n    // In a single key account contract we re-used ivpk_m as signing key\n    schnorr::assert_valid_signature(public_key, witness.signature, message_bytes);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
     },
-    "64": {
+    "57": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/account.nr",
       "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::{\n        constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n        traits::Hash,\n    },\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"
     },
-    "65": {
+    "58": {
       "path": "/home/aztec-dev/aztec-packages/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    traits::ToField,\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        .get_preimage();\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"
     },
-    "66": {
+    "59": {
       "path": "/home/aztec-dev/aztec-packages/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"
     },
-    "68": {
+    "6": {
+      "path": "std/collections/bounded_vec.nr",
+      "source": "use crate::{cmp::Eq, convert::From, runtime::is_unconstrained, static_assert};\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        if is_unconstrained() {\n            for i in 0..append_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        } else {\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        }\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        static_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        if is_unconstrained() {\n            for i in 0..self.len {\n                ret |= predicate(self.storage[i]);\n            }\n        } else {\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        }\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\n        if is_unconstrained() {\n            for i in 0..self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i < self.len() {\n                    ret.storage[i] = f(self.get_unchecked(i));\n                }\n            }\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\n        if is_unconstrained() {\n            for i in len..MaxLen {\n                array[i] = zeroed;\n            }\n        } else {\n            for i in 0..MaxLen {\n                if i >= len {\n                    array[i] = zeroed;\n                }\n            }\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        use crate::convert::From;\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"
+    },
+    "61": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
       "source": "use dep::aztec::{\n    prelude::PrivateContext,\n    protocol_types::{\n        constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n        hash::poseidon2_hash_with_separator,\n        traits::{Hash, Serialize},\n    },\n};\nuse std::meta::derive;\n\nuse crate::entrypoint::function_call::FunctionCall;\n\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\n#[derive(Serialize)]\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\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_args_hash(\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_args_hash(\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"
     },
-    "69": {
+    "62": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
       "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::{\n    prelude::PrivateContext,\n    protocol_types::{\n        constants::GENERATOR_INDEX__FEE_PAYLOAD,\n        hash::poseidon2_hash_with_separator,\n        traits::{Hash, Serialize},\n    },\n};\nuse std::meta::derive;\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\n#[derive(Serialize)]\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 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_args_hash(\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_args_hash(\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"
     },
-    "81": {
+    "74": {
       "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
       "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::{Empty, FromField, Hash, ToField},\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            // Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            // for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        // the number of side effects that took place), along with the hash of the return values. We validate these\n        // by requesting a private kernel iteration in which the return values are constrained to hash\n        // to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+    },
+    "94": {
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "source": "use dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::{Hash, ToField},\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }
 }