@aztec/accounts 0.71.0 → 0.73.0

package/artifacts/SchnorrSingleKeyAccount.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.1+2d73c1d7bc5b1db7",
+  "noir_version": "1.0.0-beta.1+dec21f055eaccab1",
   "name": "SchnorrSingleKeyAccount",
   "functions": [
     {
@@ -1632,8 +1632,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
@@ -1646,93 +1646,23 @@
       "verification_key": "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"
     },
     {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "name": "sync_notes",
       "is_unconstrained": true,
       "custom_attributes": [],
       "abi": {
         "error_types": {
-          "16541607464495309456": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 16
-          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           }
         },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 0,
-              "type": {
-                "kind": "field"
-              }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
-          },
-          "visibility": "public"
-        }
+        "parameters": [],
+        "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiYHCH0TqWyvZhOsbUi/5DpTAF/QD/NCX9qvLih37MExUJGaisFK0Zmd95uyZ2Ys3HXcq/eNfJzzHoe65y0J9tqEubyuVIlZpybNzJzy7d8IzuhOesSLPjsDT1zTfEneac6k7zcemEV/yAY7gJfc/AHD2N9RZqLtgVwxIlQmD1MJfl/OXzJ0XZf5PWcBMbfAXhN+3wS+J97e6xcexkN8o1M91q+UzvONLEZ4xeQmXbF2wfWe2CGw/mA1z+CezYd4TJ9KtB2NRzKu1dVxobCmMrfNG7VyrHbaR1rkzzdGKYp4xPpw/8SmoT93y6TFbDLaM2RKwkf6+foR+PPYp9PsK7TwnI3eZw2SnmKPWFjkVG+Afy1zSncckrs99ow11j0HPR6aPxV6B+ljo7/WZvsGfnn1Ja9eUiOmJGpFmfezPbBnY4vrcTx5+x+AHsYhHwvp/Cb9Hoe7BO/T+WPDfY/7PeAttqBHHioQ26u/n5OfwPHCn/PlN/d3lOqV3mF7OpTVbD3/V4Gc2/A+En9vgLwl/YIPfnGUeTPBnJeEXNvw3hD+0yZ/mLDmy4b8n/LEJ/nxP++4n15ZmfQjPE2jXW7ur6pozEfrPGVerM9GE8eH64P7rbVOB61iw8RhOBT9TwY+ElSliPShijT7oGPuKWANFrKEilmYcU0UsTb1yRaxCEUsz7zX1ojhK5zRftqEubyzSOU0Rv5LOaZrf7qQ15VcsaIjjS1j/X0zngQnPakZ7Ds118oG+CyPf1+7X5L8Q+BDvXLDdchm7X6wPm/ViczySVcvZpolnwbjyNvwmwvUY+0t7v3TuU9S6lL77h6CrLzHYCmZLwEYcpe/+oRH/a/RH/2PBxvf/a2M5cZf74YCNG++4tipjbu//pLt54/Vrce3cJP+5u1yv3+t+EfXhZ+lc4DoWbPx8kgt+csHPPWLxO3rU0Oc16RTXrV0rlqt1+48tWosSd37v75j/hPX/E37j2Ki+Zc0/rHbV4Wl32C12r6/zl92E4fvSBZ3+Ab+1O0oNHwAA",
-      "debug_symbols": "tdfRioQgFAbgd/HaC49a5rzKsgxWNghiYbWwRO++NsTOMHM5/DfhidMnhD9yNtb7dr1dQxrGmV2+NhbHzi1hTKXads7aHGIMt+vzayaOh1X3/nly6SjnxeWFXWrBmU99WTTl6yFEX5Zq52+NRp6Nxvw3VnL/5sxqFFyh4BoFGxTcoGALgkkImEwwWcJkBZM1TK5gcg2TDUxuYDIsgwTLIMEySLAMEiyDBMsgwTJIn2XQqrOx/NY32uDoBkdbGC0FjiYcLXG0wtEaR1c4GpdGiUujxKVRgtK4l+rH5eDa6M+ZaVhT9zRCLb+Tf5mmpjx2vl+zP+aqx0h1HGKludb3W7wUpCQnZcomZaM/",
+      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "bY/RCoMwDEX/Jc99SCqO6a/IkKpRCqWVWgdD/PfFIeI2X8K94eSSu0DHzTzU1vdhgrJawIXWJBu8uGVV0ETrnB3q8xpwG5R9+Gk0frNTMjFBeUMF7DsRd7nurWOR2ar+QEJCvbOidXHglOM1X9DBa8Iv/rGKfZpoTeN4f72ffXtqkl4j/5QaY2i5myNv9U7NZFaUK40SK9Fv",
       "brillig_names": [
-        "compute_note_hash_and_optionally_a_nullifier"
+        "sync_notes"
       ]
     },
     {
@@ -1841,12 +1771,102 @@
         ],
         "return_type": null
       },
-      "bytecode": "H4sIAAAAAAAA/92caVPbMBCGHbABB0LC0fukNy1tHZKQpCctve8L+jlTyJ9oP7j9E7T/tnlBSzZCnaGDNOWtZzxOvMruo7Usr6VVCtH2ttbbC+ZzbI6j5ojz09HgJmWXzTHb31b1qCsLxVggYBwiYBwmYIwJGBMCxhECxlECxjECxpSAsUjAOE7AOEHAWCJgnCRgLBMwVggYpwIwhuCcJuGc8cipY/tQvLPRwW+jhwgYDxMwHiFgPErAeIyA8TgB4wkCxpMEjKcIGE8TMJ4hYDxLwDhHwHiOgPE8AeMFAsaLBIyXCBgvEzBeIWCcJ2C8SsB4jYBxgYDxOgHjDQLGmwSMGQFjlYBxkYCxRsBYJ2BsEDAuETA2CRhbBIxtAsZbBIy3CRjvEDDeJWC8R8B4n4BxmYDxAQHjQwLGFQLGRwSMjwkYnxAwPiVgfEbA+JyA8QUB40sCxlcEjK8JGN8QML4lYHxHwPiegPEDAePHAIwhOD+RcK6ScK4F4ow+W9BDvR0Lt7AwCguPsLAHC2ewMAULP7CwAgsXsDAAifdIbEfieKW3I/EZScVI2EUSLJJMkcSJJEkkISLJD0l0SFJDEhiSrJDEhCShs719rrcjiQRJGkiCQJIBJvExSY5JaEzyYhIVk5SYBMQkGyaxMEmEWmGSA5MIGKTHIDgGmTGIi0FSDEJikA+DaBikwiAQBlkwiCGDBHjJxUskXtLwEoSXDATxCJIRhCLIQxCFIAVBAB6yeIjhIYFOGJ0cOhHcpLgB0LjWoj9v0kh+mGNqjkNK7nERXTW17PrU38randRRP4/8tdToHAuiv9EU/WkY/kwW2q7kff26LmJ32BxX874vV/NBJimzqcpsWmWkPmGud70W1l/VxZLlo0jVRWwXw9iuFSx7+rpomdgvRiHb5vaiZG1PeGz/SN9RkjJ5n6dgyeJ8dz1EliiZXF/YmVfl7LY1ZsmEBZu035LyjWxrRibXNFY6/bXX0Pd3Pft37bVe/R/ba2zJ4nx3Pf62veq2ZbfXJOpv0peKbETJflqyUSX7lfdt1825sP3w9nNX32++n1szDn5tC9to3veBtLthdS5RPtvyjy5vyVIli/NBO0XzPVZ2tC7hSKzyNfO9bI4j6jfy+4rD/ohlf4Dbcc72S+oonzrKo30tmM+Ir9F+vkn5aPe9in3ZfM/2tS21Xf2iP/3Nmqvv88i/IfrHg+iv7+ifCMNfF/2lMP7f0T8Zhr8r+sth9C+J/koY/Q3RPxVE/+JOXKD/XMeOC2bUeY9x7J7jArFftFhDxQUzFo/tHx0XQDbrYK04ZHYfMOuwM+uw49I16VHXlEddxQNax5JHXRWPulKPunxexwmPunz6q+xR15hHXT7bvU9/yXUMOz6VZa44LQqgvxhG/07fL320fhfTdRL7iVX+q+XniSB+7o87SX+mfeGKpXza3uvzWuyXHDzCXXTI9vOHZxuNVrfdarR7IX11abGdFSz9wmqf0+9Eun/R5V3Pflfc59HXmWvMoaz8ii1WsklLliiZMOoxB1dc7JN/L/7X9isOmd0/7/VaTkeDbU3fj+NR/36Oc/91b7a2/8hli9HoT6LBMcXIsp9Y5b+b73Zft997pNvsVLu1TrfT6Kyv1790pi392ofw02+mXHNgmVMAAA==",
-      "debug_symbols": "tZbLCoMwEEX/JessnNT3r5QiUaMEQpSohSL+e0eRVtr13YRMmDmzOuGuojX10lfWd8Mkyvsq3NDo2Q6eq3WTog7WOdtX12cR7QdF0TEwjdrv9TTrMIsyjaQwvuVLzuOddYavt03+NWbqbMyyT2OitodkMsHICka+wcgxjJzAyCmMnMHIOYxcoMgEc5BgDhLMQYI5SDAHCeYgwRwkmIMEc5BgDiqYgwrmoMI4uHH11MHq2pkzQHSLby55Yn6N5idajGFoTLsEs4eMb77YXY5JJnT8oFyQiiWpgpfwojc=",
+      "bytecode": "H4sIAAAAAAAA/92c927bMBDG5URKIieOndG9927leHeme+/W/dsdfosWAtqHSPu09Zfw7DPDAilCovkqQJCto+9+PFHUiTy6EG1s3cFeMJ9jc5w2R5xfjMY3Kbtqjtn2tqpHXVkoxgIB4wQB4yQBY0zAmBAwThEwThMwzhAwpgSMRQLGWQLGOQLGEgHjPAFjmYCxQsC4EIAxBOciCeeSR04d24fiXY52fhvdRcC4m4BxDwHjXgLGfQSM+wkYDxAwHiRgPETAeJiA8QgB41ECxmMEjMcJGE8QMJ4kYDxFwHiagPEMAeNZAsZzBIznCRgvEDBeJGC8RMB4mYDxCgFjRsBYJWBcIWCsETDWCRgbBIxNAsYWAWObgLFDwHiVgPEaAeN1AsYbBIw3CRhvETCuEjDeJmC8Q8B4l4DxHgHjfQLGBwSMDwkYHxEwPiZgfELA+JSA8RkB43MCxhcEjC8JGF8RML4mYHxDwPg2AGMIzncknO9JOLuBOKMPFvTEYMfCLSyMwsIjLOzBwhksTMHCDyyswMIFLAxA4j0S25E4XhnsSHxGUjESdpEEiyRTJHEiSRJJiEjyQxIdktSQBIYkKyQxIUno6GA/NtiRRIIkDSRBIMkAk/iYJMckNCZ5MYmKSUpMAmKSDZNYmCRCrTDJgUkEDNJjEByDzBjExSApBiExyIdBNAxSYRAIgywYxJBBArzk4iUSL2l4CcJLBoJ4BMkIQhHkIYhCkIIgAA9ZPMTwkEAnjE4OnQhuUtwAaFzd6M+bNJIf5pia44SSe1xEV00tuz71t7POx9RRP4/8tdTonAmiv9ES/WkY/kwW2t7LR/p1XcTupDl285Evu/k4k5RZU2XWrDJSnzDXu14P66/qSsnyUaTqIraLYWzXCpY9fV20TOwXo5Btc2NRsrYnPLZ/pO8oSZl8xFOwZHG+uR4iS5RMri/snFfl7LY1Y8mEBZu035LyjWwfjEyuaax0+muvjXbY9lrP/l17rVf/x/YaW7I431yPv22vum3Z7TWJRpv0pSKbUrKflmxayX7lI9sNxdE0n8P2yRvPYH3v+X6GLTn4tS1s0/nIH9IGJ9W5RPlv3T+6vCVLlSzOx+0UzfdY2dG6hCOxytfN97I5TqnfyO8rDvtTlv0xbsc52y+po3zqKI+2dsl8njU72tA3+U20+d7Fvmq+Z9vamh1XP+lPf6vm6gs98n8R/bNB9NeH+ufC8A/jqlIY/w/1z4fh74v+chj9TdFfCaO/IfoXguhfGcYJ+s927DhhSZ33GNduOU4Q+0WLNVScsGTx2P7RcQJkyw7WikNm9wHLDjvLDjsuXfMedS141FXcoXUsedRV8agr9ajL53Wc86jLp7/KHnXNeNTls9379Jdcx7DjVVnmitOiAPqLYfQP+37po/W7ma6T2E+s8l8tP88F8fNoHEr6M+0LVyzl0/ZWn9div+TgEe6iQ7adP0D70mj3O+1GZxDSV5srnaxg6RdW+5x+L9L9iy7veva74j6Pvs5cYxBl5VdssZLNW7JEyYRRj0G44mKf/Fvxv7Zfccjs/nmr13IxGm9r+n6cjUb3c5z7r3urvfHHLuuMRn8SjY8xRpb9xCr/3Xy3+7rt3iP9Vq/ar/X6vUbv8+f6p96ipV/7EH76DXVGL3ipUwAA",
+      "debug_symbols": "tZZBCoMwEEXvknUWzli17VVKKVGjBEKUqIUi3r2jSCvt+m9CJkzekMULf1a1Laf24ULTDep6m5XvKjO6Lkg1L1qV0Xnv2sfxWCXrQglvF4behLUeRhNHdc0TrWyoZXOW643zVrbpov8aC94bi+LTmPFy10JOYeQTjJzByDmMXMDIZxj5giJTAiMTjAxzkGAOEsxBgjlIMAcJ5iDBHCSYgwxzkGEOMsxBhjnIGAcXqZ4mOlN6uweIZgrVIU+Mr97+RIs+dpWtp2jXkPHNF+vbT6wz3n59KYhzTSnJEBn0Bg==",
       "brillig_names": [
         "process_log"
       ]
     },
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16541607464495309456": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 16
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "packed_note_content",
+            "type": {
+              "kind": "array",
+              "length": 0,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "H4sIAAAAAAAA/9VZy67aQAwdSEJIuAEKn3Cl7tomXJ47Fn3c30AFPqHrrLppP7qMGCcH46siYVfFEpoknhyfOXZmJqHjztY//TrhOA5tz10b9dmGtrzPKkWs0pJn50F4dh+EZ/QgPGNFnh2Bp2/peUvc+ZlL3fl5bC7iTT7BEdzk/gYAwX6HNgttF/yKCakyYZBa+Otyvs/cpSnzf8kCZmqDvyD8vg1+Sbw/1y0+joXiRqF9rVstX+Eeb0U4xuIlXPJ1wfeF+SLwfWU+rOFvzId1T5xIN1qYlOtqY50XGlsKY+u80TrXaofXSOvcmdZoRTnPGB/On/gU1Kdu+fSYLwZfxnwJ+Eh/3z5DP577FPp9hONP0IfXZ+Su65n8lH/U3aK+YgP8k82lHPD8xPVlbPRhDmLQ85npY7FuoD4W+nt9pm/wp2Nvae0ai5ieqBFp1sf+zJeBL64v4+ThPIY4iEU8Etb/QzgfhbYH99D9YyF+j8W/4C1cQ404ViRco/7++Xwfjgfh52voJ93jructvc31ci7N4Xr4qwY/s+F/JPzcBn9J+AMb/GZv82SCPysJv7Dh38xBQ5v6afaWIxv+B8Ifm+DPD7QOv3OtNXNEOJ7Adb35u6pu2SNh/JxxtdojTRgfrg+uwd43FbiOBR/P4VSIMxXiSFiZItaTItboPx1jXxFroIg1VMTSzGOqiKWpV66IVShiada9pl6UR2mf5m0b2vJOk/ZpiviVtE/TfJcnram+YkFDHF/C+v9gOg9MeFYzWnPoWacYGLswin3rek3xC4EP8c4F3z0fZw+L9XGzXmxOW7JqOds0+SwYV34N34twPsb+0tov7fsUtS6ld/8h6OotBl/BfAn4iKP07j804n+L/hh/LPj4+n9rLifuej0csHHjN6+typjb74HSt3rj+Wtx67NJ8XN3PV//q++NqA/fS+cC17Hg4/uTXIiTC3EeEYt/s0cNfV2TTnHd+rVyuVq3f3TRXJS4y/8BHIufsP6/wjmOjdp75vzjalcdX3bH3WK338+/7yYM31sXdPoDg5oBSR0fAAA=",
+      "debug_symbols": "tZfBisMgFEX/xbULn8YY+yvDUExiiiAmmGRgCPn3MSVMS7ssdxN84XrceMC7sd636+0a0jDO7PK1sTh2bgljKtO2c9bmEGO4XZ9/M3F8rL7n58mlY5wXlxd2qQVnPvVl0ZTdQ4i+LNXO34JGnkFj/oNa7t+c2RoFNihwgwJbEJiEgJEJRpYwsoKRKxhZw8g1jGxg5AZGhjlIMAcJ5iDBHCSYgwRzkGAOEsxBgjlInzlo1RksV+ENbWFoKXBowqElDq1w6AqH1jh0jUMbHBpno8TZqHA2KpCNe5l+XA6ujf5sTcOauqcStfxO/qVPTXnsfL9mfzSrR6k61FOaV/r+8igDqYqTsuWQctAf",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
+    },
     {
       "name": "entrypoint",
       "is_unconstrained": false,
@@ -3635,8 +3655,8 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
@@ -3651,26 +3671,6 @@
         "directive_integer_quotient"
       ],
       "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VTvQ6CMBBu+YmCMqiJbia+QREMjCbuvkMDMuqAixuPLjXX9FKbMLQ18Uuaa+Hy/ZSDEgUKNSIWkCQHqAnUAL0Px3WGM7NDnmi6LvlrVhaJIZ9D/x9+6sm/gOT3dP9sBjyXQfHjLFJ3Pq4UzYSvzPKb+cy8mci5+kHOEcdM08aghmehoYci3zvYZ4Y+iQVR/3Q0uM9V1YxJvRD4Y/LtHevHWv8WzqnmX9TIwmdX8bwreMdPvG3Lhq81foEA3dM/z8Ie9lOzgDMuiZqN/nVvro/nrScTECRvfuFT84YGAAA=",
-      "debug_symbols": "nZJBDoMgFETvwpoFHxVsr2Iag4qGhIBBbNIY7140prWNG9j8zPzMm9UsqJPNPNTK9HZC92pB2rbCK2uCW1aMGqe0VkN9fiOyHYA9P43CbHbywnl0ZwQjabogykD3Sssgs/WBEdDIfBaZzyPzRVyeXvYDISU/ECAA+YeCnO1YkYaxNIynYWUSlsE1Bpx9sVvxi63BPoVTotHyGFk/m/a0Of8a5d/8Rmdb2c1ObkM8bTDcCjimNNSG6jc=",
-      "brillig_names": [
-        "sync_notes"
-      ]
     }
   ],
   "outputs": {
@@ -3891,21 +3891,21 @@
     }
   },
   "file_map": {
-    "132": {
+    "136": {
       "path": "/build-volume/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"
     },
-    "133": {
+    "137": {
       "path": "/build-volume/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"
     },
-    "135": {
+    "139": {
       "path": "/build-volume/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\n/// Stores values represented as array in execution cache to be later obtained by its hash.\npub fn store_array<let N: u32>(values: [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. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_array_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 store_array_in_execution_cache_oracle_wrapper<let N: u32>(values: [Field; N]) {\n    let _ = store_array_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(storeArrayInExecutionCache)]\nunconstrained fn store_array_in_execution_cache_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
+      "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"
     },
-    "146": {
+    "150": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_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            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note_content,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        packed_note_content,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note_content: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::unpack_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
     "17": {
       "path": "std/embedded_curve_ops.nr",
@@ -3915,47 +3915,47 @@
       "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        /*@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        */\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            /*@safety: decomposition is properly checked below*/\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            //@safety: unsafe in unconstrained\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            //@safety: Take a hint of the comparison and verify it\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"
     },
-    "180": {
+    "184": {
       "path": "/build-volume/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"
     },
     "19": {
       "path": "std/field/mod.nr",
-      "source": "pub mod bn254;\nuse crate::runtime::is_unconstrained;\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        assert(BIT_SIZE < modulus_num_bits() as u32);\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    // 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\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    // 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\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        // 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        // 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            crate::assert_constant(radix);\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    #[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        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            //@safety : unconstrained context\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 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        let field = 2;\n        let bytes: [u8; 8] = field.to_be_radix(256);\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_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_radix(256);\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_radix_example\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"
+      "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            //@safety : unconstrained context\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        let field = 2;\n        let bytes: [u8; 8] = field.to_be_radix(256);\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_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_radix(256);\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_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"
     },
     "21": {
       "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 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"
     },
-    "244": {
+    "251": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, 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\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
     "26": {
       "path": "std/hash/poseidon2.nr",
       "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        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"
     },
-    "260": {
+    "267": {
       "path": "/build-volume/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"
     },
-    "261": {
+    "268": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\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_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "278": {
+    "285": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
       "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "287": {
+    "294": {
       "path": "/build-volume/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"
     },
-    "326": {
+    "334": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "335": {
+    "346": {
       "path": "/root/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"
     },
@@ -3989,23 +3989,23 @@
     },
     "69": {
       "path": "/build-volume/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
-      "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_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"
+      "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"
     },
     "7": {
       "path": "std/collections/bounded_vec.nr",
-      "source": "use crate::{cmp::Eq, convert::From};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if !exceeded_len {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n        for i in 0..MaxLen {\n            if i < self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        }\n        ret\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n        for i in 0..MaxLen {\n            if i >= len {\n                array[i] = zeroed;\n            }\n        }\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n        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"
+      "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"
     },
     "70": {
       "path": "/build-volume/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
-      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_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"
+      "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": {
       "path": "/build-volume/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        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        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_array(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_array(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_array(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_array(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_array(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        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": {
+    "97": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
+      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }
 }