@aztec/accounts 0.65.1 → 0.66.0

package/artifacts/SchnorrSingleKeyAccount.json

@@ -1,6 +1,6 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+c8ff97767236adc0817b37c116f045c62eb981a1-x8664",
+  "noir_version": "1.0.0-beta.0+a46035ba69b0a659897fe25271c346e005925a6c-x8664",
   "name": "SchnorrSingleKeyAccount",
   "functions": [
     {
@@ -88,36 +88,17 @@
         }
       },
       "bytecode": "H4sIAAAAAAAA/9VZ227aQBBdsI2xiQmFP4jUt1ayCdc3pF7yHSiBL+gH+KEv7VeXFTv2YTypkJipykjRGs/6zNkz4931pufONjz99cJ1HNqB6xr12YW2vM0qRazSkmfvTnj274RndCc8Y0WePYGnb+l9S9z5nUvd+X3sOPFhn+gI/O5vQCzo79Bmoe2DXzExVSYMVgt/Uy5eM3dpyvyfs4CZ2uAvCX9og18S7y91i49jobhRaF/qVssXeMZbEa6xiAmXfH3wfWW+CHzfmA9r+DvzYd0TJ9JtAGNRrKuNdV5obCmMrfdO61yrHd4jrXNnWqMV5TxjfDh/4lNQn7rlM2C+GHwZ8yXgI/19+wT9eO5T6PcZ7vOajFy3hslPOUetLWoqNsA/2ULSneckri9jow91j0HPJ6aPxVqB+ljo7/WZvcOfrr2ltWssYnqiRqTZEPszXwa+uL6Mk4ffMcRBLOKRsP6fwu/H0A7gGXp+IsQfsPgXvIV7qBHHioR71N+/kx/D9cid6+cn9XfdeUpvU71aSHO2Hv66wc9s+B8JP7fBXxH+yAa/2cs8mODPS8IvbPhvCX9sUz/NXvLRhv+B8Ccm+IsDrbsfXGvN/BCup3Bfb+6uqmv2RBg/Z1yt9kRTxofrg+uv980ErhPBx3M4E+LMhDgSVqaI9aCI9fifjnGoiDVSxBorYmnmMVXE0tQrV8QqFLE0615TL8qjtE/ztgtteaNJ+zRF/Erap2l+u5PWVF+xoCGOL2H9fzCdRyY8qzmtOfSuUwyMXRjFvna9pviFwId454LvlkPZw3Jz3G6W29OWrFrNt00+C8aV38NvIpyPsb+09kv7PkWtS+m7fwy6eovBVzBfAj7iKH33j434X6M/xp8IPr7+X5vLqeuuhyM2bjzj2qmMuT3/k87mjeev5bXvJsXPXXe+/lfni6gP30vnAteJ4OP7k1yIkwtx7hGLn9Gjhr6uSae4bv1auVxv2n9w0VyUuMtzf8fiJ6z/r/Abx0btLXP+cb2vjs/74365f3tbvO6nDN9bH3T6A/vRhmkVHwAA",
-      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbE77FwO/0104vQJ4o+cnQ2+2+63kMZpYe3HzuLUuzVMqVT7wVmXQ4zhfnv+zMT5sOrRv8wuneWyuryythac+TSUl6b8PYboWaulPvhLp5FXpzG/nRUdn5xZDZMrmFzDZAOTG5hsUTIJgaMJR0scrXC0xtEVjq5xtMHRDY7GpZFwaSRcGgmXRsKlkXBpJFwa6c00WnV1lq19sQ3QboC2xdlSAG0C2hJoK6CtgXYFtIG5lMBcSmAuJSqXR6m+XA6ui/4arMYt9U9z1vo9+38j15yn3g9b9ufw9Td3nWdZaa7142ovBSnJSZmySFnoBw==",
+      "debug_symbols": "tdfRioQgFAbgd/HaC49aZq+yLIOVDYJYWC0s0buvDbE77FwO/0104vQJ4o+cnQ2+2+63kMZpYe3HzuLUuzVMqVT7wVmXQ4zhfnv+zMT5sOrRv8wuneWyuryythac+TSUl6b8PYboWauVPPhLp5FXpzG/nRUdn5xZDZMrmFzDZAOTG5hsUTIJgaMJR0scrXC0xtEVjq5xtMHRDY7GpZFwaSRcGgmXRsKlkXBpJFwa6c00WnV1lq19sQ3QboC2xdlSAG0C2hJoK6CtgXYFtIG5lMBcSmAuJSqXR6m+XA6ui/4arMYt9U9z1vo9+38j15yn3g9b9ufw9Td3nWdZaa7142ovBSnJSZmySFnoBw==",
       "brillig_names": [
         "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLNCoQgEAfwd5lzh7S0j1eJJawsBLEwW1iid98p2qVduuhlcMTfzMH/Cp1slqFWph9nKKsV9NgKp0aD3bpF0FiltRrq6zXEeyHkeD9Pwuzt7IR1UPI4Amk6POSoe6UllClNt0cEhPqCxBekvoB5Anq7oWA0P0nBGPsiQsmBWAjiISgLQXkASm5/v+Ak+yCe8F+0YfsUVolGyzNd/WLaS9jca5J/uZvs2MpusXJP4CV8WCvcRSmOxdFv",
-      "brillig_names": [
-        "sync_notes"
-      ]
-    },
-    {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private"
+        "private",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -129,13 +110,17 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "5019202896831570965": {
+          "19458536156181958": {
             "error_kind": "string",
-            "string": "attempt to add with overflow"
+            "string": "Function verify_private_authwit can only be called statically"
           },
-          "5727012404371710682": {
+          "4939791462094160055": {
             "error_kind": "string",
-            "string": "push out of bounds"
+            "string": "Message not authorized by account"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
           },
           "6485997221020871071": {
             "error_kind": "string",
@@ -608,173 +593,9 @@
             "visibility": "private"
           },
           {
-            "name": "app_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 4,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::app::AppPayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "fee_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 2,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                },
-                {
-                  "name": "is_fee_payer",
-                  "type": {
-                    "kind": "boolean"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::fee::FeePayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "cancellable",
+            "name": "inner_hash",
             "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -1081,7 +902,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -1265,7 +1086,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -1380,36 +1201,33 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
-                        "name": "counter",
+                        "name": "note_hash_counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -1417,13 +1235,7 @@
                         }
                       },
                       {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "note_hash_counter",
+                        "name": "counter",
                         "type": {
                           "kind": "integer",
                           "sign": "unsigned",
@@ -1432,15 +1244,15 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
               {
-                "name": "encrypted_logs_hashes",
+                "name": "contract_class_logs_hashes",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 1,
                   "type": {
                     "fields": [
                       {
@@ -1462,50 +1274,27 @@
                         "type": {
                           "kind": "field"
                         }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
                   }
                 }
               },
               {
-                "name": "contract_class_logs_hashes",
+                "name": "start_side_effect_counter",
                 "type": {
-                  "kind": "array",
-                  "length": 1,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::LogHash"
-                  }
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
                 }
               },
               {
@@ -1895,29 +1684,25 @@
           "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",
         "lte_hint",
-        "enqueue_public_function_call_internal",
-        "call_private_function_internal",
-        "debug_log_oracle_wrapper",
-        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
+        "pack_returns_oracle_wrapper",
         "directive_to_radix",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "276b5434ac1f4ec77b1325d6224d183983db7ea8-8f5f4ec5837d6fbb54256d7ae7036636-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-9e46ddc0d812ed1c7f905e43befa6173-mega-honk-true"
     },
     {
-      "name": "verify_private_authwit",
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private",
-        "view"
+        "private"
       ],
       "abi": {
         "error_types": {
@@ -1929,18 +1714,14 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
-            "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
-          },
-          "4939791462094160055": {
-            "error_kind": "string",
-            "string": "Message not authorized by account"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
           "6485997221020871071": {
             "error_kind": "string",
             "string": "call to assert_max_bit_size"
@@ -2297,124 +2078,288 @@
                   }
                 },
                 {
-                  "name": "tx_context",
+                  "name": "tx_context",
+                  "type": {
+                    "fields": [
+                      {
+                        "name": "chain_id",
+                        "type": {
+                          "kind": "field"
+                        }
+                      },
+                      {
+                        "name": "version",
+                        "type": {
+                          "kind": "field"
+                        }
+                      },
+                      {
+                        "name": "gas_settings",
+                        "type": {
+                          "fields": [
+                            {
+                              "name": "gas_limits",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "da_gas",
+                                    "type": {
+                                      "kind": "integer",
+                                      "sign": "unsigned",
+                                      "width": 32
+                                    }
+                                  },
+                                  {
+                                    "name": "l2_gas",
+                                    "type": {
+                                      "kind": "integer",
+                                      "sign": "unsigned",
+                                      "width": 32
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas::Gas"
+                              }
+                            },
+                            {
+                              "name": "teardown_gas_limits",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "da_gas",
+                                    "type": {
+                                      "kind": "integer",
+                                      "sign": "unsigned",
+                                      "width": 32
+                                    }
+                                  },
+                                  {
+                                    "name": "l2_gas",
+                                    "type": {
+                                      "kind": "integer",
+                                      "sign": "unsigned",
+                                      "width": 32
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas::Gas"
+                              }
+                            },
+                            {
+                              "name": "max_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
+                        }
+                      }
+                    ],
+                    "kind": "struct",
+                    "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
+                  }
+                },
+                {
+                  "name": "start_side_effect_counter",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "app_payload",
+            "type": {
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 4,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::entrypoint::app::AppPayload"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "fee_payload",
+            "type": {
+              "fields": [
+                {
+                  "name": "function_calls",
+                  "type": {
+                    "kind": "array",
+                    "length": 2,
+                    "type": {
+                      "fields": [
+                        {
+                          "name": "args_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "function_selector",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "integer",
+                                  "sign": "unsigned",
+                                  "width": 32
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
+                          }
+                        },
+                        {
+                          "name": "target_address",
+                          "type": {
+                            "fields": [
+                              {
+                                "name": "inner",
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            ],
+                            "kind": "struct",
+                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                          }
+                        },
+                        {
+                          "name": "is_public",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        },
+                        {
+                          "name": "is_static",
+                          "type": {
+                            "kind": "boolean"
+                          }
+                        }
+                      ],
+                      "kind": "struct",
+                      "path": "authwit::entrypoint::function_call::FunctionCall"
+                    }
+                  }
+                },
+                {
+                  "name": "nonce",
                   "type": {
-                    "fields": [
-                      {
-                        "name": "chain_id",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "version",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "gas_settings",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "gas_limits",
-                              "type": {
-                                "fields": [
-                                  {
-                                    "name": "da_gas",
-                                    "type": {
-                                      "kind": "integer",
-                                      "sign": "unsigned",
-                                      "width": 32
-                                    }
-                                  },
-                                  {
-                                    "name": "l2_gas",
-                                    "type": {
-                                      "kind": "integer",
-                                      "sign": "unsigned",
-                                      "width": 32
-                                    }
-                                  }
-                                ],
-                                "kind": "struct",
-                                "path": "authwit::aztec::protocol_types::abis::gas::Gas"
-                              }
-                            },
-                            {
-                              "name": "teardown_gas_limits",
-                              "type": {
-                                "fields": [
-                                  {
-                                    "name": "da_gas",
-                                    "type": {
-                                      "kind": "integer",
-                                      "sign": "unsigned",
-                                      "width": 32
-                                    }
-                                  },
-                                  {
-                                    "name": "l2_gas",
-                                    "type": {
-                                      "kind": "integer",
-                                      "sign": "unsigned",
-                                      "width": 32
-                                    }
-                                  }
-                                ],
-                                "kind": "struct",
-                                "path": "authwit::aztec::protocol_types::abis::gas::Gas"
-                              }
-                            },
-                            {
-                              "name": "max_fees_per_gas",
-                              "type": {
-                                "fields": [
-                                  {
-                                    "name": "fee_per_da_gas",
-                                    "type": {
-                                      "kind": "field"
-                                    }
-                                  },
-                                  {
-                                    "name": "fee_per_l2_gas",
-                                    "type": {
-                                      "kind": "field"
-                                    }
-                                  }
-                                ],
-                                "kind": "struct",
-                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
+                    "kind": "field"
                   }
                 },
                 {
-                  "name": "start_side_effect_counter",
+                  "name": "is_fee_payer",
                   "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
+                    "kind": "boolean"
                   }
                 }
               ],
               "kind": "struct",
-              "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs"
+              "path": "authwit::entrypoint::fee::FeePayload"
             },
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "name": "cancellable",
             "type": {
-              "kind": "field"
+              "kind": "boolean"
             },
             "visibility": "private"
           }
@@ -2721,7 +2666,7 @@
                 "name": "private_call_requests",
                 "type": {
                   "kind": "array",
-                  "length": 4,
+                  "length": 5,
                   "type": {
                     "fields": [
                       {
@@ -2905,7 +2850,7 @@
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::side_effect::Counted"
+                    "path": "authwit::aztec::protocol_types::abis::side_effect::counted::Counted"
                   }
                 }
               },
@@ -3020,46 +2965,29 @@
                 }
               },
               {
-                "name": "start_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "end_side_effect_counter",
-                "type": {
-                  "kind": "integer",
-                  "sign": "unsigned",
-                  "width": 32
-                }
-              },
-              {
-                "name": "note_encrypted_logs_hashes",
+                "name": "private_logs",
                 "type": {
                   "kind": "array",
                   "length": 16,
                   "type": {
                     "fields": [
                       {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "counter",
-                        "type": {
-                          "kind": "integer",
-                          "sign": "unsigned",
-                          "width": 32
-                        }
-                      },
-                      {
-                        "name": "length",
+                        "name": "log",
                         "type": {
-                          "kind": "field"
+                          "fields": [
+                            {
+                              "name": "fields",
+                              "type": {
+                                "kind": "array",
+                                "length": 18,
+                                "type": {
+                                  "kind": "field"
+                                }
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::abis::log::Log"
                         }
                       },
                       {
@@ -3069,25 +2997,6 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::NoteLogHash"
-                  }
-                }
-              },
-              {
-                "name": "encrypted_logs_hashes",
-                "type": {
-                  "kind": "array",
-                  "length": 4,
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "value",
-                        "type": {
-                          "kind": "field"
-                        }
                       },
                       {
                         "name": "counter",
@@ -3096,22 +3005,10 @@
                           "sign": "unsigned",
                           "width": 32
                         }
-                      },
-                      {
-                        "name": "length",
-                        "type": {
-                          "kind": "field"
-                        }
-                      },
-                      {
-                        "name": "randomness",
-                        "type": {
-                          "kind": "field"
-                        }
                       }
                     ],
                     "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::abis::log_hash::EncryptedLogHash"
+                    "path": "authwit::aztec::protocol_types::abis::private_log::PrivateLogData"
                   }
                 }
               },
@@ -3148,6 +3045,22 @@
                   }
                 }
               },
+              {
+                "name": "start_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
+              {
+                "name": "end_side_effect_counter",
+                "type": {
+                  "kind": "integer",
+                  "sign": "unsigned",
+                  "width": 32
+                }
+              },
               {
                 "name": "historical_header",
                 "type": {
@@ -3535,19 +3448,42 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "7Z3djhRHEoXfZa65yIyf/PGrrCwLY2whIbAAr7Sy/O7bPaaqG6o2ymxP9gRx0hcWDTkxcaI6o0/G1Hz158Mvr3/+47ef3rz79f3Hhx/+9efD2/evXn568/7d6dWfD5ke/+7j7y/fnV9+/PTyw6eHH3Lp6cXD63e/nP5YU/rrxcOvb96+fvhBSP56sVlNjdvn1dTKZXXWvLOaNffPq1k7Hazu1PLn1Z26rquJ+s7q3FpZ8u7panXZW5xpSSTn2q4X//jiIfMszH5hZBZmvzA6C7NfmHJ7YSSTfl4tueSL1ESP36KO/xbtW7/F+Yv63hf1RMuFYDp6R3RaFnPqdV1ddG9xqrKsptTaJZ9KO8tPC/jz6tZyOXpHyJpJFsm3vCMozbLslSXPsuyVhXyXRdJaFpX7tVXiWZa9ssgsy15Z9NaycNa6lCV3tsuSU5c1GaKvPxepuMqmusqmucqme8qGk6tssqtsyFU27CobcZWNq17Mrnoxu+rF7KoXs6teLK56sbjqxeKqF4urXiyuerG46sXiqheLq14srnqxuOrF6qoXq6terK56sbrqxeqqF6urXqyuerG66sXqqherq15cXPXi4qoXF1e9uLjqxcVVLy6uenFx1YuLq15cXPXi4qoXV1e9uLrqxdVVL66uenF11Yurq15cXfXi6qoXV1e9uLrqxc1VL26uenFz1Yubq17cXPXi5qoXN1e9uLnqxc1VL26uenF31Yu7q17cXfXi7qoX9zv34syXbOrhzfO83N9OqldreWet0JqGUL2kkfduw1NJy214+vitL4vPNdFZk01NyqzJpiZ11mRTkzZrsqlJnzX5uiY5pVmUbVHyLMq2KDSLsi0Kz6JsiyKzKNuiTDe7U5RpZ3eKMv3sTlGmod0pynS026Lk6Wh3ijId7U5RpqPdKcp0tDtFkVmUbVGmo90pynS0O0WZjnanKNPR7hRlOtptUWg62p2iTEe7U5TpaHeKMh3tTlFkFmVblOlod4oyHe1OUaaj3SlKGEdb0hJZCqWNzjAm1dbJYXzngc4wVvJAZxh3WHQlypa61RnG8B3oFBCdYWzZgc4wTutAZxjzdNBvQfwQg/ghAfFDEscPmX1IQPyQgPihewPwnk0niB8SED8kcfyQrTOOH7J1xvFDpk6N44dsnSB+SEH8kIL4oXtDKJ9NZxw/ZJ7LNI4fsnWCzIcUZD6kIH6ogPihAuKHCogfKiB+6N4g2GfTCTIfKiDzoQIyHyog86EC4ocqiB+qIH6ogvihGscPmeeye8OYn00nyHyogsyHKogfqiB+qIL4oQbihxqIH2ogfqiBzIfuDUR/Np0g86EGMh9qIH6ogfihBuKHOogf6iC/X9bj+CFbJ8h8KM5DCQ50gvihOA8PONAJ4ofiQP4PdGL4IYrD4j/QiTEfojjE/AOdGPMhSgKiE8MPURz6/IFODD9EcRjxBzoxft+e4pDcD3RizIcoDm/9QCeIH4pDRT/QCeKH4rDLD3SC+KE4hPEDnSDzoTgc8AOdIPOhOLTuA50gfigOU/tAJ4gfikO+PtCJ8fv2BMKnJhA+NYHwqSkQn9rsQyB8agLhUxMIn5pA+NQEwqemQHxqWyfIfCgQn9rUGYhPbesE8UMgfGoC4VMTCJ+aAvGpzXNZID61rRNkPhSIT23rBPFDIHxqAuFTEwifmkD41ATCp6ZAfGpbJ8h8KBCf2tYJMh8C4VMTCJ+aQPjUBMKnpkB8avNcFohPbesEmQ8F4lPbOkH8EAifmkD41ATCpyYQPjWB8KkpEJ/a1ikgOkHmQ4H41LZOED8EwqcmED41gfCpKRCf2jyXBeJT2zpB5kOB+NS2ThA/BMKnJhA+NYHwqQmET00gfGoKxKe2dYLMhwLxqW2dAqITxA+B8KkJhE9NIHxqCsSnts5lHIhPbevEmA9xID61rRPDD3ESEJ0YfohB+NQMwqdmED41B+JTmzoD8altnRjzIQ7Ep7Z1gvghED41g/CpGYRPzYH41Oa5LBCf2tYJMh8KxKe2dYL4IRA+NYPwqRmET80gfGoG4VNzID61rRNkPhSIT23qDMSntnWC+CEQPjWD8KkZhE/NgfjU5rksEJ/a1gkyHwrEp7Z1gvghED41g/CpGYRPzSB8agbhU3MgPrWtE2Q+FIhPbesEmQ+B8KkZhE/NIHxqBuFTcyA+tXkuC8SntnWCzIcC8altnSB+CIRPzSB8agbhUzMIn5pB+NQciE9t6xQQnSDzoUB8alsniB8C4VMzCJ+aQfjUHIhPbZ7LAvGpbZ0g86FAfGpbJ4gfAuFTMwifmkH41AzCp2YQPjUH4lPbOkHmQ4H41LZOAdEJ4odA+NQMwqdmED41B+JTm+eyQHxqWyfIfCgQn9rWCeKHQPjUDMKnZhA+NYPwqRmET82B+NSWTgnEp7Z1YsyHJBCf2taJ4YckCYhODD8kIHxqCcSnts5lEohPbevEmA9JID61rRPED4HwqQWETy0gfGoB4VMLCJ9aAvGpbZ0Y8yEJxKc2dQbiU9s6QfwQCJ9aQPjUAsKnlkB8avNcFohPbesEmQ8F4lPbOkH8EAifWkD41ALCpxYQPrWA8KklEJ/a1gkyHwrEp7Z1gsyHQPjUAsKnFhA+tYDwqSUQn9o8lwXiU9s6QeZDgfjUtk4QPwTCpxYQPrWA8KkFhE8tIHxqCcSntnUKiE6Q+VAgPrWtE8QPgfCpBYRPLSB8agnEpzbPZYH41LZOkPlQID61rRPED4HwqQWETy0gfGoB4VMLCJ9aAvGpbZ0g86FAfGpbp4DoBPFDIHxqAeFTCwifWgLxqc1zWSA+ta0TZD4UiE9t6wTxQyB8agHhUwsIn1pA+NQCwqeWQHxqU2cgPrWtE2Q+FIhPbesE8UMgfGoB4VMLCJ9aAvGpzXNZID61rRNjPqSB+NS2Tgw/pCB8agXhU2sSEJ0YfkhB+NQaiE9t68SYD2kgPrWpMxCf2tYJ4odA+NQKwqdWED61BuJTm+eyQHxqWyfGfEgD8altnSB+CIRPrSB8agXhUysIn1pB+NQaiE9t6wSZDwXiU9s6QeZDIHxqBeFTKwifWkH41BqIT22eywLxqW2dIPOhQHxqWyeIHwLhUysIn1pB+NQKwqdWED61BuJT2zoFRCfIfCgQn9rWCeKHQPjUCsKnVhA+tQbiU5vnskB8alsnyHwoEJ/a1gnih0D41ArCp1YQPrWC8KkVhE+tgfjUtk6Q+VAgPrWtU0B0gvghED61gvCpFYRPrYH41Oa5LBCf2tYJMh8KxKe2dYL4IRA+tYLwqRWET60gfGoF4VNrID61qTMQn9rWCTIfCsSntnWC+CEQPrWC8KkVhE+tgfjU5rksEJ/a1gkyHwrEp7Z1gvghED61gvCpFYRPrSB8agXhU2sgPrWtE2Q+FIhPbeksgfjUtk4MP1RA+NQFhE99MvkgOjF+374E4lPbOjHmQyUQn9rWCeKHQPjUBYRPXUD41AWET11A+NQlEJ/a1okxHyqB+NS2Toz5UAHhUxcQPnUB4VMXED51CcSnNs9lgfjUtk6Q+VAgPrWtE8QPgfCpCwifuoDwqQsIn7qA8KlLID61rVNAdILMhwLxqW2dIH4IhE9dQPjUBYRPXQLxqc1zWSA+ta0TZD4EwqcuIHzqAsKnLiB86gLCpy4gfOoSiE9tfq6A8KkLCJ+6BOJT2/tTQHSC+CEQPnUB4VMXED51CcSnNj9XAvGpbZ0gfigQn9rWCeKHQPjUBYRPXUD41AWET11A+NQlEJ/a1BmIT23rBLl/KBCf2tYZxg/Vtiw+/ZE3OsWxTl4vkSb6Qudj6p4tjuY1ddZt6p5diwp/XlwSH7y7qJWyvBVbuyRNaTfpRLQmLe3qvUg7q1tLSyKt5XKJTX1Po6yxs0i+rC67BaF+KUi7Xvx4eTybrXl5XDO75+VxjRqfl8c1IX1eHtdg93l5XPPo5+VxjdGfl8c1/X9eHtcPLZiXx/WzFublcf2IiHl5XD/ZYl4e1w/kmJfH9XNE5uVx/fgTP5dH0np5VI4uT2tLJrknve3yzKmB68sTZmrQ87KYU5WDy/OMBZdZ8PsWPMzJ/nspeJSzOmdaC55LPSg4iSxVIWmX1bke1vvq1pT2dwmjnKdHlrCvt8jkfvUuPJVwu1jKUg3pmxuBXD/oyEm1KaX1xqtEcku1o5x2R1Y7r62eMvev2kN1/SQnLyU8rV4WU2P7DZu51fU8evXxt9Q7yhHze6l3lDOjm3orL3lk1fL/d+/q+mFc4JdG5qV54ktTV4epvd1yaaKcQQNemjin1aSXS9MOLs1p6r4olNN/9qXhulaQW+brxY8ljHNaHVfC1pfzE/edEsY5gj5bCeOcK5+rhK6fiPedlDDOUfHZShjn9PdsJYxzSnu2Esos4a0ljHPqebYSztPJzSUMeTqpRzeg5LT+/Denmu0Sau5L0kpZNiUMeTq5bwlDnk7uWkLXz6f8TkoY8nTyxCUkKWsJS9mUMOTp5L4lDHk6uW8JZZbw1hKGPJ08cQlLXay11nzgw2vhpd61tI0Pd/2404j1nuee43q3vNa7Kd1W73lIeup696Uc9TRX39R7nqjuWu97Pw439Uu96cvQj+lkX+nMH1r8g0Hdmgc3rZs32Pyhxc0llKcsIaV8XcLHb7BrmnPpa0+q6aiUpeflc7R0veozae9X47S3ZTFfFedMkzy9+vnDm7dv3/z209v3r15+evP+3cfzV6bz//Y3ZFtvX2pXdy8J7b1BpK7Hh6up8qnlngqx/159sugyNLoOjV6GRq9Do+9auFaX6D2Vg+iX+5q5tS/WnsP3oeH3n8/6dOHz2PA0NjyPDS9jw+vY8GVs+Do2/NhdK2N3rY7dtTp21+rYXatjd62O3bU6dtfq2F2rY3etjt215ebay4oxl1w34W/OXi8+pG7D96HhaxobPo8NT2PD89jwMja8jg1fxoavY8OP3bV17K5tY3dtG7tr29hd227ftUrrhIcO1pZ1SHKaYGxSET+pqJ9Uip9Uqp9UmptUer5rKryuvZp5nqaPj6nceQctRq+UvElF/aRS/KRS/aRy+w6itjva3z1z9L4ElnQV+Yx1OyfTHSWTU3KVTb5nNpLWB4VJuv6pypINucqGXWUj982m9jWbTtts1FU2xVU21VU27bmyySlts+messnJVTb37cWUl8WnH5jnbTbkKht2lY24yua+vZi0rNmUvs2muMqmusqmucrmvr2Y03Jnj/DV7H7JhpKrbLKrbMhVNvxs2ZBusxFX2airbO7bi2W9DU5Et2dNqq6yaa6y6Z6y4fv2Yrk8EVz69uTL2VU25CobdpXNfXuxrsRzUdmefFldZVNcZVNdZdOeLRvdnsO5e8pGkqts7tuLy/p0Fyl1e4IRcpUNu8pGXGVz315cL7645rbNprjKprrKprnK5r69uOrqi2vZnnw1ucomu8qGXGXDz5ZN3Z7DVVxlo66yGdiLH+Pf3F1LW1pUuTrzrPHb4Ph9bPySxsav970rxbqDKdf73thV1rpcOaI1l+4nlye4ifXpcsmOciFHubCjXMRRLn7uBczNz82Aufm5GzDf+4ZaM5fuJ5eeHOWSHeVCjnJhR7mIo1wc9V1HN2FnR3dh5+6o73Y/fZeSn75Lt99lbP5OLKWbe8bpRzaXUcs2vg6OXwbHr4Pj37wHReplgLKN38fGv/0e2YP4eXB8GhyfB8eXwfH1CeM33sYvg+PXwfFv3798hRLbxu9j499+X+VB/Dw4Pg2Oz4Pjy+D4Ojh+GRy/Do4/eP/S4P3Lg/cvD96/PHj/8sj9e3qVzyv3P4RzWkGuOfHVj7b2nnd6+UF3zXS99Hw40rHhy+3h1+chV/n6yff7n8DfGH65BLXw1+Hb2PD99vBtuWeq9vpV+P2P36cLn28O32i5c6fJ1++c/Q/fbwy/nE7blw/Sfty8t4evy6Vt2+LIE4bvX22r0wsyWkNe8a6nP7Z/tmOyrI9PzqUcJJZ0obu2VK/e1P0xNT4v3b89rtK6Ga5v8DuzW/8XkdH+Evn2L9Fv/5LyjV/y1+nlv19+ePPy57evzwDa87/+8e7VwqM9vfz0n9+Xf1mItb9/eP/q9S9/fHh9ZtdesLXnPXz+ZSqq5cfH2v6L+PRKzq8ez8d0OkKQ0vllflzLp5d6+fh4XFNfMF3eNn/HfMFpvVznuJxeSFqiSnuhfBJyEvNf",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_auth_witness",
         "decompose_hint",
         "lte_hint",
-        "pack_returns_oracle_wrapper",
+        "enqueue_public_function_call_internal",
+        "call_private_function_internal",
+        "debug_log_oracle_wrapper",
+        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
         "directive_to_radix",
         "directive_invert",
         "directive_integer_quotient"
       ],
-      "verification_key": "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",
-      "artifact_hash": "276b5434ac1f4ec77b1325d6224d183983db7ea8-ec71cbf6b02842460cd7e959fb97601a-mega-honk-true"
+      "verification_key": "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",
+      "artifact_hash": "51138cca3416c965bb4ccec1358c0c804a4ada84-d3d22b0b1c576bab0484f5bce48953c8-mega-honk-true"
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgEAbgd5lzh7TM7FViCSsLQTTMFpbo3dd2t6VduuhlcMRvPMy/Qi/aZWykHswMVb2CMh130mjfrVsCrZVKybE5X0O6F4Re7+eJ672dHbcOqiJNQOjeH0qvB6kEVHmGt1sCCIeCLBTkoYAEAnz5A8vJQVhO6Rch9EYkBhUxiMagMgJll9tnJGMHIqT8RZtv79xK3irxSdew6O4UNveYxF/uJms60S9W7Ak8hc/XGtEEYz/Wj34C",
+      "brillig_names": [
+        "sync_notes"
+      ]
     }
   ],
   "outputs": {
@@ -3770,7 +3706,7 @@
   "file_map": {
     "7": {
       "path": "std/collections/bounded_vec.nr",
-      "source": "use crate::{cmp::Eq, convert::From};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if !exceeded_len {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n        for i in 0..MaxLen {\n            if i < self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        }\n        ret\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        (self.len == other.len) & (self.storage == other.storage)\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n}\n"
+      "source": "use crate::{cmp::Eq, convert::From};\n\n/// A `BoundedVec<T, MaxLen>` is a growable storage similar to a `Vec<T>` except that it\n/// is bounded with a maximum possible length. Unlike `Vec`, `BoundedVec` is not implemented\n/// via slices and thus is not subject to the same restrictions slices are (notably, nested\n/// slices - and thus nested vectors as well - are disallowed).\n///\n/// Since a BoundedVec is backed by a normal array under the hood, growing the BoundedVec by\n/// pushing an additional element is also more efficient - the length only needs to be increased\n/// by one.\n///\n/// For these reasons `BoundedVec<T, N>` should generally be preferred over `Vec<T>` when there\n/// is a reasonable maximum bound that can be placed on the vector.\n///\n/// Example:\n///\n/// ```noir\n/// let mut vector: BoundedVec<Field, 10> = BoundedVec::new();\n/// for i in 0..5 {\n///     vector.push(i);\n/// }\n/// assert(vector.len() == 5);\n/// assert(vector.max_len() == 10);\n/// ```\npub struct BoundedVec<T, let MaxLen: u32> {\n    storage: [T; MaxLen],\n    len: u32,\n}\n\nimpl<T, let MaxLen: u32> BoundedVec<T, MaxLen> {\n    /// Creates a new, empty vector of length zero.\n    ///\n    /// Since this container is backed by an array internally, it still needs an initial value\n    /// to give each element. To resolve this, each element is zeroed internally. This value\n    /// is guaranteed to be inaccessible unless `get_unchecked` is used.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let empty_vector: BoundedVec<Field, 10> = BoundedVec::new();\n    /// assert(empty_vector.len() == 0);\n    /// ```\n    ///\n    /// Note that whenever calling `new` the maximum length of the vector should always be specified\n    /// via a type signature:\n    ///\n    /// ```noir\n    /// fn good() -> BoundedVec<Field, 10> {\n    ///     // Ok! MaxLen is specified with a type annotation\n    ///     let v1: BoundedVec<Field, 3> = BoundedVec::new();\n    ///     let v2 = BoundedVec::new();\n    ///\n    ///     // Ok! MaxLen is known from the type of `good`'s return value\n    ///     v2\n    /// }\n    ///\n    /// fn bad() {\n    ///     // Error: Type annotation needed\n    ///     // The compiler can't infer `MaxLen` from the following code:\n    ///     let mut v3 = BoundedVec::new();\n    ///     v3.push(5);\n    /// }\n    /// ```\n    ///\n    /// This defaulting of `MaxLen` (and numeric generics in general) to zero may change in future noir versions\n    /// but for now make sure to use type annotations when using bounded vectors. Otherwise, you will receive a\n    /// constraint failure at runtime when the vec is pushed to.\n    pub fn new() -> Self {\n        let zeroed = crate::mem::zeroed();\n        BoundedVec { storage: [zeroed; MaxLen], len: 0 }\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this\n    /// will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     let last = v.get(v.len() - 1);\n    ///     assert(first != last);\n    /// }\n    /// ```\n    pub fn get(self, index: u32) -> T {\n        assert(index < self.len, \"Attempted to read past end of BoundedVec\");\n        self.get_unchecked(index)\n    }\n\n    /// Retrieves an element from the vector at the given index, starting from zero, without\n    /// performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element,\n    /// it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn sum_of_first_three<let N: u32>(v: BoundedVec<u32, N>) -> u32 {\n    ///     // Always ensure the length is larger than the largest\n    ///     // index passed to get_unchecked\n    ///     assert(v.len() > 2);\n    ///     let first = v.get_unchecked(0);\n    ///     let second = v.get_unchecked(1);\n    ///     let third = v.get_unchecked(2);\n    ///     first + second + third\n    /// }\n    /// ```\n    pub fn get_unchecked(self, index: u32) -> T {\n        self.storage[index]\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero.\n    ///\n    /// If the given index is equal to or greater than the length of the vector, this will issue a constraint failure.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn foo<let N: u32>(v: BoundedVec<u32, N>) {\n    ///     let first = v.get(0);\n    ///     assert(first != 42);\n    ///     v.set(0, 42);\n    ///     let new_first = v.get(0);\n    ///     assert(new_first == 42);\n    /// }\n    /// ```\n    pub fn set(&mut self, index: u32, value: T) {\n        assert(index < self.len, \"Attempted to write past end of BoundedVec\");\n        self.set_unchecked(index, value)\n    }\n\n    /// Writes an element to the vector at the given index, starting from zero, without performing a bounds check.\n    ///\n    /// Since this function does not perform a bounds check on length before accessing the element, it is unsafe! Use at your own risk!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn set_unchecked_example() {\n    ///     let mut vec: BoundedVec<u32, 5> = BoundedVec::new();\n    ///     vec.extend_from_array([1, 2]);\n    ///\n    ///     // Here we're safely writing within the valid range of `vec`\n    ///     // `vec` now has the value [42, 2]\n    ///     vec.set_unchecked(0, 42);\n    ///\n    ///     // We can then safely read this value back out of `vec`.\n    ///     // Notice that we use the checked version of `get` which would prevent reading unsafe values.\n    ///     assert_eq(vec.get(0), 42);\n    ///\n    ///     // We've now written past the end of `vec`.\n    ///     // As this index is still within the maximum potential length of `v`,\n    ///     // it won't cause a constraint failure.\n    ///     vec.set_unchecked(2, 42);\n    ///     println(vec);\n    ///\n    ///     // This will write past the end of the maximum potential length of `vec`,\n    ///     // it will then trigger a constraint failure.\n    ///     vec.set_unchecked(5, 42);\n    ///     println(vec);\n    /// }\n    /// ```\n    pub fn set_unchecked(&mut self, index: u32, value: T) {\n        self.storage[index] = value;\n    }\n\n    /// Pushes an element to the end of the vector. This increases the length\n    /// of the vector by one.\n    ///\n    /// Panics if the new length of the vector will be greater than the max length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    ///\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// // Panics with failed assertion \"push out of bounds\"\n    /// v.push(3);\n    /// ```\n    pub fn push(&mut self, elem: T) {\n        assert(self.len < MaxLen, \"push out of bounds\");\n\n        self.storage[self.len] = elem;\n        self.len += 1;\n    }\n\n    /// Returns the current length of this vector\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 4> = BoundedVec::new();\n    /// assert(v.len() == 0);\n    ///\n    /// v.push(100);\n    /// assert(v.len() == 1);\n    ///\n    /// v.push(200);\n    /// v.push(300);\n    /// v.push(400);\n    /// assert(v.len() == 4);\n    ///\n    /// let _ = v.pop();\n    /// let _ = v.pop();\n    /// assert(v.len() == 2);\n    /// ```\n    pub fn len(self) -> u32 {\n        self.len\n    }\n\n    /// Returns the maximum length of this vector. This is always\n    /// equal to the `MaxLen` parameter this vector was initialized with.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.max_len() == 5);\n    /// v.push(10);\n    /// assert(v.max_len() == 5);\n    /// ```\n    pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u32 {\n        MaxLen\n    }\n\n    /// Returns the internal array within this vector.\n    ///\n    /// Since arrays in Noir are immutable, mutating the returned storage array will not mutate\n    /// the storage held internally by this vector.\n    ///\n    /// Note that uninitialized elements may be zeroed out!\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 5> = BoundedVec::new();\n    ///\n    /// assert(v.storage() == [0, 0, 0, 0, 0]);\n    ///\n    /// v.push(57);\n    /// assert(v.storage() == [57, 0, 0, 0, 0]);\n    /// ```\n    pub fn storage(self) -> [T; MaxLen] {\n        self.storage\n    }\n\n    /// Pushes each element from the given array to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_array([2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_array<let Len: u32>(&mut self, array: [T; Len]) {\n        let new_len = self.len + array.len();\n        assert(new_len <= MaxLen, \"extend_from_array out of bounds\");\n        for i in 0..array.len() {\n            self.storage[self.len + i] = array[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the given slice to this vector.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut vec: BoundedVec<Field, 3> = BoundedVec::new();\n    /// vec.extend_from_slice(&[2, 4]);\n    ///\n    /// assert(vec.len == 2);\n    /// assert(vec.get(0) == 2);\n    /// assert(vec.get(1) == 4);\n    /// ```\n    pub fn extend_from_slice(&mut self, slice: [T]) {\n        let new_len = self.len + slice.len();\n        assert(new_len <= MaxLen, \"extend_from_slice out of bounds\");\n        for i in 0..slice.len() {\n            self.storage[self.len + i] = slice[i];\n        }\n        self.len = new_len;\n    }\n\n    /// Pushes each element from the other vector to this vector. The length of\n    /// the other vector is left unchanged.\n    ///\n    /// Panics if pushing each element would cause the length of this vector\n    /// to exceed the maximum length.\n    ///\n    /// ```noir\n    /// let mut v1: BoundedVec<Field, 5> = BoundedVec::new();\n    /// let mut v2: BoundedVec<Field, 7> = BoundedVec::new();\n    ///\n    /// v2.extend_from_array([1, 2, 3]);\n    /// v1.extend_from_bounded_vec(v2);\n    ///\n    /// assert(v1.storage() == [1, 2, 3, 0, 0]);\n    /// assert(v2.storage() == [1, 2, 3, 0, 0, 0, 0]);\n    /// ```\n    pub fn extend_from_bounded_vec<let Len: u32>(&mut self, vec: BoundedVec<T, Len>) {\n        let append_len = vec.len();\n        let new_len = self.len + append_len;\n        assert(new_len <= MaxLen, \"extend_from_bounded_vec out of bounds\");\n\n        let mut exceeded_len = false;\n        for i in 0..Len {\n            exceeded_len |= i == append_len;\n            if !exceeded_len {\n                self.storage[self.len + i] = vec.get_unchecked(i);\n            }\n        }\n        self.len = new_len;\n    }\n\n    /// Creates a new vector, populating it with values derived from an array input.\n    /// The maximum length of the vector is determined based on the type signature.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array([1, 2, 3])\n    /// ```\n    pub fn from_array<let Len: u32>(array: [T; Len]) -> Self {\n        assert(Len <= MaxLen, \"from array out of bounds\");\n        let mut vec: BoundedVec<T, MaxLen> = BoundedVec::new();\n        vec.extend_from_array(array);\n        vec\n    }\n\n    /// Pops the element at the end of the vector. This will decrease the length\n    /// of the vector by one.\n    ///\n    /// Panics if the vector is empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<Field, 2> = BoundedVec::new();\n    /// v.push(1);\n    /// v.push(2);\n    ///\n    /// let two = v.pop();\n    /// let one = v.pop();\n    ///\n    /// assert(two == 2);\n    /// assert(one == 1);\n    ///\n    /// // error: cannot pop from an empty vector\n    /// let _ = v.pop();\n    /// ```\n    pub fn pop(&mut self) -> T {\n        assert(self.len > 0);\n        self.len -= 1;\n\n        let elem = self.storage[self.len];\n        self.storage[self.len] = crate::mem::zeroed();\n        elem\n    }\n\n    /// Returns true if the given predicate returns true for any element\n    /// in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let mut v: BoundedVec<u32, 3> = BoundedVec::new();\n    /// v.extend_from_array([2, 4, 6]);\n    ///\n    /// let all_even = !v.any(|elem: u32| elem % 2 != 0);\n    /// assert(all_even);\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        let mut exceeded_len = false;\n        for i in 0..MaxLen {\n            exceeded_len |= i == self.len;\n            if !exceeded_len {\n                ret |= predicate(self.storage[i]);\n            }\n        }\n        ret\n    }\n\n    /// Creates a new vector of equal size by calling a closure on each element in this vector.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n    /// let result = vec.map(|value| value * 2);\n    ///\n    /// let expected = BoundedVec::from_array([2, 4, 6, 8]);\n    /// assert_eq(result, expected);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> BoundedVec<U, MaxLen> {\n        let mut ret = BoundedVec::new();\n        ret.len = self.len();\n        for i in 0..MaxLen {\n            if i < self.len() {\n                ret.storage[i] = f(self.get_unchecked(i));\n            }\n        }\n        ret\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function will zero out any elements at or past index `len` of `array`.\n    /// This incurs an extra runtime cost of O(MaxLen). If you are sure your array is\n    /// zeroed after that index, you can use `from_parts_unchecked` to remove the extra loop.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    /// ```\n    pub fn from_parts(mut array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        let zeroed = crate::mem::zeroed();\n        for i in 0..MaxLen {\n            if i >= len {\n                array[i] = zeroed;\n            }\n        }\n        BoundedVec { storage: array, len }\n    }\n\n    /// Creates a new BoundedVec from the given array and length.\n    /// The given length must be less than or equal to the length of the array.\n    ///\n    /// This function is unsafe because it expects all elements past the `len` index\n    /// of `array` to be zeroed, but does not check for this internally. Use `from_parts`\n    /// for a safe version of this function which does zero out any indices past the\n    /// given length. Invalidating this assumption can notably cause `BoundedVec::eq`\n    /// to give incorrect results since it will check even elements past `len`.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n    /// assert_eq(vec.len(), 3);\n    ///\n    /// // invalid use!\n    /// let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n    /// let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n    ///\n    /// // both vecs have length 3 so we'd expect them to be equal, but this\n    /// // fails because elements past the length are still checked in eq\n    /// assert_eq(vec1, vec2); // fails\n    /// ```\n    pub fn from_parts_unchecked(array: [T; MaxLen], len: u32) -> Self {\n        assert(len <= MaxLen);\n        BoundedVec { storage: array, len }\n    }\n}\n\nimpl<T, let MaxLen: u32> Eq for BoundedVec<T, MaxLen>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: BoundedVec<T, MaxLen>) -> bool {\n        // TODO: https://github.com/noir-lang/noir/issues/4837\n        //\n        // We make the assumption that the user has used the proper interface for working with `BoundedVec`s\n        // rather than directly manipulating the internal fields as this can result in an inconsistent internal state.\n        if self.len == other.len {\n            self.storage == other.storage\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T, let MaxLen: u32, let Len: u32> From<[T; Len]> for BoundedVec<T, MaxLen> {\n    fn from(array: [T; Len]) -> BoundedVec<T, MaxLen> {\n        BoundedVec::from_array(array)\n    }\n}\n\nmod bounded_vec_tests {\n\n    mod get {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test(should_fail_with = \"Attempted to read past end of BoundedVec\")]\n        fn panics_when_reading_elements_past_end_of_vec() {\n            let vec: BoundedVec<Field, 5> = BoundedVec::new();\n\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod set {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn set_updates_values_properly() {\n            let mut vec = BoundedVec::from_array([0, 0, 0, 0, 0]);\n\n            vec.set(0, 42);\n            assert_eq(vec.storage, [42, 0, 0, 0, 0]);\n\n            vec.set(1, 43);\n            assert_eq(vec.storage, [42, 43, 0, 0, 0]);\n\n            vec.set(2, 44);\n            assert_eq(vec.storage, [42, 43, 44, 0, 0]);\n\n            vec.set(1, 10);\n            assert_eq(vec.storage, [42, 10, 44, 0, 0]);\n\n            vec.set(0, 0);\n            assert_eq(vec.storage, [0, 10, 44, 0, 0]);\n        }\n\n        #[test(should_fail_with = \"Attempted to write past end of BoundedVec\")]\n        fn panics_when_writing_elements_past_end_of_vec() {\n            let mut vec: BoundedVec<Field, 5> = BoundedVec::new();\n            vec.set(0, 42);\n\n            // Need to use println to avoid DIE removing the write operation.\n            crate::println(vec.get(0));\n        }\n    }\n\n    mod map {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn applies_function_correctly() {\n            // docs:start:bounded-vec-map-example\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| value * 2);\n            // docs:end:bounded-vec-map-example\n            let expected = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn applies_function_that_changes_return_type() {\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_array([1, 2, 3, 4]);\n            let result = vec.map(|value| (value * 2) as Field);\n            let expected: BoundedVec<Field, 4> = BoundedVec::from_array([2, 4, 6, 8]);\n\n            assert_eq(result, expected);\n        }\n\n        #[test]\n        fn does_not_apply_function_past_len() {\n            let vec: BoundedVec<u32, 3> = BoundedVec::from_array([0, 1]);\n            let result = vec.map(|value| if value == 0 { 5 } else { value });\n            let expected = BoundedVec::from_array([5, 1]);\n\n            assert_eq(result, expected);\n            assert_eq(result.get_unchecked(2), 0);\n        }\n    }\n\n    mod from_array {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty() {\n            let empty_array: [Field; 0] = [];\n            let bounded_vec = BoundedVec::from_array([]);\n\n            assert_eq(bounded_vec.max_len(), 0);\n            assert_eq(bounded_vec.len(), 0);\n            assert_eq(bounded_vec.storage(), empty_array);\n        }\n\n        #[test]\n        fn equal_len() {\n            let array = [1, 2, 3];\n            let bounded_vec = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 3);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.storage(), array);\n        }\n\n        #[test]\n        fn max_len_greater_then_array_len() {\n            let array = [1, 2, 3];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from_array(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 3);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n            assert_eq(bounded_vec.get(2), 3);\n        }\n\n        #[test(should_fail_with = \"from array out of bounds\")]\n        fn max_len_lower_then_array_len() {\n            let _: BoundedVec<Field, 2> = BoundedVec::from_array([0; 3]);\n        }\n    }\n\n    mod trait_from {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn simple() {\n            let array = [1, 2];\n            let bounded_vec: BoundedVec<Field, 10> = BoundedVec::from(array);\n\n            assert_eq(bounded_vec.max_len(), 10);\n            assert_eq(bounded_vec.len(), 2);\n            assert_eq(bounded_vec.get(0), 1);\n            assert_eq(bounded_vec.get(1), 2);\n        }\n    }\n\n    mod trait_eq {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn empty_equality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n\n            assert_eq(bounded_vec1, bounded_vec2);\n        }\n\n        #[test]\n        fn inequality() {\n            let mut bounded_vec1: BoundedVec<Field, 3> = BoundedVec::new();\n            let mut bounded_vec2: BoundedVec<Field, 3> = BoundedVec::new();\n            bounded_vec1.push(1);\n            bounded_vec2.push(2);\n\n            assert(bounded_vec1 != bounded_vec2);\n        }\n    }\n\n    mod from_parts {\n        use crate::collections::bounded_vec::BoundedVec;\n\n        #[test]\n        fn from_parts() {\n            // docs:start:from-parts\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // Any elements past the given length are zeroed out, so these\n            // two BoundedVecs will be completely equal\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts([1, 2, 3, 2], 3);\n            assert_eq(vec1, vec2);\n            // docs:end:from-parts\n        }\n\n        #[test]\n        fn from_parts_unchecked() {\n            // docs:start:from-parts-unchecked\n            let vec: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 0], 3);\n            assert_eq(vec.len(), 3);\n\n            // invalid use!\n            let vec1: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 1], 3);\n            let vec2: BoundedVec<u32, 4> = BoundedVec::from_parts_unchecked([1, 2, 3, 2], 3);\n\n            // both vecs have length 3 so we'd expect them to be equal, but this\n            // fails because elements past the length are still checked in eq\n            assert(vec1 != vec2);\n            // docs:end:from-parts-unchecked\n        }\n    }\n}\n"
     },
     "17": {
       "path": "std/embedded_curve_ops.nr",
@@ -3784,91 +3720,99 @@
       "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        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use 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"
     },
+    "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    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"
+    },
     "26": {
       "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        if message_size == N {\n            Poseidon2::hash_internal(input, N, false)\n        } else {\n            Poseidon2::hash_internal(input, message_size, true)\n        }\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
     "51": {
       "path": "std/panic.nr",
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
-    "65": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/account.nr",
-      "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
-    },
-    "67": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
-      "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
-    },
-    "68": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
-      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
-    },
-    "71": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
-      "source": "#[oracle(getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/**\n * Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\n *\n * @param message_hash The hash of the message for which the `auth_witness` is to be fetched.\n * @return The `auth_witness` for the given `message_hash` as Field array.\n */\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n"
-    },
-    "72": {
-      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth.nr",
-      "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` have authorized the current call with a valid authentication witness\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that have authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that have authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .unpack_into();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allow same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` have authorized the current call in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that have authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` have authorized a speicifc `inner_hash` in the authentication registry\n *\n * Computing the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then making a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that have authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computs the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that have authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
-    },
-    "102": {
+    "93": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        logs::{emit_encrypted_event_log, emit_encrypted_note_log},\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log_hash::{EncryptedLogHash, LogHash, NoteLogHash},\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENCRYPTED_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_ENCRYPTED_LOGS_PER_CALL, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n        MAX_NOTE_HASHES_PER_CALL, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub note_encrypted_logs_hashes: BoundedVec<NoteLogHash, MAX_NOTE_ENCRYPTED_LOGS_PER_CALL>,\n    pub encrypted_logs_hashes: BoundedVec<EncryptedLogHash, MAX_ENCRYPTED_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            note_encrypted_logs_hashes: self.note_encrypted_logs_hashes.storage(),\n            encrypted_logs_hashes: self.encrypted_logs_hashes.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    // NB: A randomness value of 0 signals that the kernels should not mask the contract address\n    // used in siloing later on e.g. 'handshaking' contract w/ known address.\n    pub fn emit_raw_event_log_with_masked_address<let M: u32>(\n        &mut self,\n        randomness: Field,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let contract_address = self.this_address();\n        let len = log.len() as Field + 4;\n        let side_effect = EncryptedLogHash { value: log_hash, counter, length: len, randomness };\n        self.encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_event_log(contract_address, randomness, log, counter);\n    }\n\n    pub fn emit_raw_note_log<let M: u32>(\n        &mut self,\n        note_hash_counter: u32,\n        log: [u8; M],\n        log_hash: Field,\n    ) {\n        let counter = self.next_counter();\n        let len = log.len() as Field + 4;\n        let side_effect = NoteLogHash { value: log_hash, counter, length: len, note_hash_counter };\n        self.note_encrypted_logs_hashes.push(side_effect);\n\n        emit_encrypted_note_log(note_hash_counter, log, counter);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            note_encrypted_logs_hashes: BoundedVec::new(),\n            encrypted_logs_hashes: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        header::get_header_at,\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    header::Header,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: Header,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_header(self) -> Header {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_header_at(self, block_number: u32) -> Header {\n        get_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: Header::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "120": {
+    "111": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "121": {
+    "112": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag as an array of bytes, ready to be included in a\n/// log.\npub unconstrained fn get_app_tag_bytes_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> [u8; 32] {\n    let tag = get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient);\n    tag.to_be_bytes()\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+      "source": "use crate::note::{note_header::NoteHeader, note_interface::NoteInterface};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n    utils::arr_copy_slice,\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let header = NoteHeader { contract_address, nonce, storage_slot, note_hash_counter };\n            let serialized_note = arr_copy_slice(fields, [0; N], read_offset + 2);\n            let mut note = Note::deserialize_content(serialized_note);\n            note.set_header(header);\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_app_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_app_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivpsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_app_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_app_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getAppTaggingSecretAsSender)]\nunconstrained fn get_app_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "123": {
+    "114": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
       "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
     },
-    "129": {
+    "120": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "151": {
+    "142": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
       "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "192": {
+    "183": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "200": {
+    "191": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "204": {
+    "195": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n    utils,\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n\n    pub fn conditional_assign(predicate: bool, lhs: Self, rhs: Self) -> Self {\n        let result = utils::conditional_assign(predicate, rhs.to_field(), lhs.to_field());\n        Self { inner: result }\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "229": {
+    "220": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedEncryptedLogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn silo_encrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    // We assume contract address has already been masked\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        accumulate_sha256(\n            [log_hash.contract_address.to_field(), log_hash.log_hash.value],\n        )\n    }\n}\n\npub fn mask_encrypted_log_hash(scoped_log: ScopedEncryptedLogHash) -> AztecAddress {\n    if scoped_log.contract_address.is_zero() {\n        AztecAddress::from_field(0)\n    } else if (scoped_log.log_hash.randomness == 0) {\n        scoped_log.contract_address\n    } else {\n        AztecAddress::from_field(poseidon2_hash_with_separator(\n            [scoped_log.contract_address.to_field(), scoped_log.log_hash.randomness],\n            0,\n        ))\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::field::field_from_bytes;\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, note_hash: Field) -> Field {\n    let inputs = [nonce, note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, unique_note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), unique_note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash, tx_hash: Field, note_index_in_tx: u32) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        let unique_note_hash = compute_unique_note_hash(nonce, note_hash.value());\n        compute_siloed_note_hash(note_hash.contract_address, unique_note_hash)\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of N + 1\n    let in_len = N + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    // We manually hash the inputs here, since we cannot express with the type system a constant size inputs array of Math.ceil(N/31)\n    let mut in_len = N / 31;\n    let mut has_padding = false;\n    if N % 31 != 0 {\n        in_len += 1;\n        has_padding = true;\n    }\n\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            sponge.absorb(field_from_bytes(current_field, false));\n            current_field = [0; 31];\n        }\n    }\n    if has_padding {\n        sponge.absorb(field_from_bytes(current_field, false));\n    }\n\n    sponge.squeeze()\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "313": {
+    "308": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "315": {
+    "310": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/mod.nr",
       "source": "// general util packages/modules are usually bad practice\n// because there is no criteria for what we should not put in here.\n// Reducing the size of this package would be welcome.\n\npub mod arrays;\npub mod field;\npub mod reader;\npub mod uint256;\n\n// if predicate == true then return lhs, else return rhs\npub fn conditional_assign(predicate: bool, lhs: Field, rhs: Field) -> Field {\n    if predicate {\n        lhs\n    } else {\n        rhs\n    }\n}\n\npub fn arr_copy_slice<T, let N: u32, let M: u32>(\n    src: [T; N],\n    mut dst: [T; M],\n    offset: u32,\n) -> [T; M] {\n    let iterator_len = if N > M { M } else { N };\n    for i in 0..iterator_len {\n        dst[i] = src[i + offset];\n    }\n    dst\n}\n"
     },
-    "423": {
+    "334": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/account.nr",
+      "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
+    },
+    "336": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
+      "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
+    },
+    "337": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
+      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
+    },
+    "340": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
+      "source": "#[oracle(getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/**\n * Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\n *\n * @param message_hash The hash of the message for which the `auth_witness` is to be fetched.\n * @return The `auth_witness` for the given `message_hash` as Field array.\n */\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n"
+    },
+    "341": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth.nr",
+      "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .unpack_into();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
+    },
+    "429": {
+      "path": "/root/nargo/github.com/noir-lang/schnorrv0.1.1/src/lib.nr",
+      "source": "use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};\nuse std::hash::{blake2s, pedersen_hash};\n\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let r = multi_scalar_mul([g1, public_key], [sig_s, sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\n//Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\nfn scalar_from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n    let mut v: Field = 1;\n    let mut lo: Field = 0;\n    let mut hi: Field = 0;\n    for i in 0..16 {\n        lo = lo + (bytes[offset + 31 - i] as Field) * v;\n        hi = hi + (bytes[offset + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    let sig_s = EmbeddedCurveScalar::new(lo, hi);\n    sig_s\n}\n\nmod test {\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    use super::verify_signature;\n\n    #[test]\n    fn test_zero_signature() {\n        let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860,\n            is_infinite: false,\n        };\n        let signature: [u8; 64] = [0; 64];\n        let message: [u8; _] = [2; 64]; // every message\n        let verified = verify_signature(public_key, signature, message);\n        assert(!verified);\n    }\n\n    #[test]\n    fn smoke_test() {\n        let message: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n        let pub_key_x: Field = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;\n        let pub_key_y: Field = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;\n        let signature: [u8; 64] = [\n            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,\n            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84,\n            247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64,\n            199, 19, 84, 239, 138, 124, 12,\n        ];\n\n        let pub_key = EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };\n        let valid_signature = verify_signature(pub_key, signature, message);\n        assert(valid_signature);\n        super::assert_valid_signature(pub_key, signature, message);\n    }\n\n}\n\nmod bench {\n    use super::{assert_valid_signature, verify_signature};\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    #[export]\n    pub fn bench_verify_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) -> bool {\n        verify_signature(public_key, signature, message)\n    }\n\n    #[export]\n    pub fn bench_assert_valid_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) {\n        assert_valid_signature(public_key, signature, message)\n    }\n}\n"
+    },
+    "431": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/util.nr",
-      "source": "use crate::auth_oracle::AuthWitness;\nuse dep::aztec::prelude::AztecAddress;\nuse std::schnorr::verify_signature;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    // In a single key account contract we re-used ivpk_m as signing key\n    let verification = verify_signature(\n        witness.keys.ivpk_m.inner.x,\n        witness.keys.ivpk_m.inner.y,\n        witness.signature,\n        message_bytes,\n    );\n    assert(verification == true);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
+      "source": "use crate::auth_oracle::AuthWitness;\nuse dep::aztec::prelude::AztecAddress;\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\n\npub fn recover_address(message_hash: Field, witness: AuthWitness) -> AztecAddress {\n    let message_bytes: [u8; 32] = message_hash.to_be_bytes();\n    let public_key = EmbeddedCurvePoint {\n        x: witness.keys.ivpk_m.inner.x,\n        y: witness.keys.ivpk_m.inner.y,\n        is_infinite: false,\n    };\n\n    // In a single key account contract we re-used ivpk_m as signing key\n    schnorr::assert_valid_signature(public_key, witness.signature, message_bytes);\n\n    AztecAddress::compute(witness.keys, witness.partial_address)\n}\n"
     },
-    "424": {
+    "432": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/main.nr",
       "source": "mod util;\nmod auth_oracle;\n\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrSingleKeyAccount {\n    use dep::aztec::prelude::PrivateContext;\n\n    use dep::authwit::{account::AccountActions, entrypoint::{app::AppPayload, fee::FeePayload}};\n\n    use crate::{auth_oracle::get_auth_witness, util::recover_address};\n\n    use dep::aztec::macros::functions::{private, view};\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts\n    #[private]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        let witness = unsafe { get_auth_witness(outer_hash) };\n        recover_address(outer_hash, witness).eq(context.this_address())\n    }\n}\n"
     },
-    "425": {
+    "433": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_single_key_account_contract/src/auth_oracle.nr",
       "source": "use dep::authwit::auth_witness;\nuse dep::aztec::protocol_types::{\n    address::PartialAddress,\n    public_keys::{PUBLIC_KEYS_LENGTH, PublicKeys},\n    utils::arr_copy_slice,\n};\n\npub struct AuthWitness {\n    keys: PublicKeys,\n    signature: [u8; 64],\n    partial_address: PartialAddress,\n}\n\nimpl AuthWitness {\n    fn deserialize(values: [Field; 77]) -> Self {\n        let mut signature = [0; 64];\n        for i in 0..64 {\n            signature[i] = values[i + PUBLIC_KEYS_LENGTH] as u8;\n        }\n        Self {\n            keys: PublicKeys::deserialize(arr_copy_slice(values, [0; PUBLIC_KEYS_LENGTH], 0)),\n            signature,\n            partial_address: PartialAddress::from_field(values[76]),\n        }\n    }\n}\n\npub unconstrained fn get_auth_witness(message_hash: Field) -> AuthWitness {\n    let witness: [Field; 77] = auth_witness::get_auth_witness(message_hash);\n    AuthWitness::deserialize(witness)\n}\n"
     }