@aztec/accounts 0.67.0 → 0.67.1-devnet

package/artifacts/SchnorrAccount.json

@@ -1,74 +1,173 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.0+b3f4ad661c8c6f88544d714fd5b7b6f58a8ce4ad-x8664",
+  "noir_version": "1.0.0-beta.0+4184522b3ac6c4ce82aadf4911289cdf9fb0dd79-x8664",
   "name": "SchnorrAccount",
   "functions": [
     {
-      "name": "sync_notes",
+      "name": "compute_note_hash_and_optionally_a_nullifier",
       "is_unconstrained": true,
       "custom_attributes": [],
       "abi": {
         "error_types": {
+          "11091894166229312484": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 20
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8270195893599566439": {
+            "error_kind": "string",
+            "string": "Invalid public keys hint for address"
           }
         },
-        "parameters": [],
-        "return_type": null
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 3,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
       },
-      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
-      "debug_symbols": "ndLLCoQgFAbgdznrFnnpYq8SQ1hZCKJhNjBE7z4azdAMbWxz8Be/4+ZfoRftMjZSD2aGql5BmY47abRP65ZAa6VScmzO15CGgdD+fp64DnF23DqoMEUJCN2HE/N+kEpARUm6PRJAOJ6QeELjSRZN8OUvjLD8MIxi8kUM7Sa7YfIbprhhynhDLivAaJl9TJbSH7P59ORW8laJo2HDortT4dxrEn/dm6zpRL9YEVp4KqCfNSoSjP1av/oN",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "sync_notes"
+        "compute_note_hash_and_optionally_a_nullifier"
       ]
     },
     {
-      "name": "verify_private_authwit",
+      "name": "constructor",
       "is_unconstrained": false,
       "custom_attributes": [
         "private",
-        "noinitcheck",
-        "view"
+        "initializer"
       ],
       "abi": {
         "error_types": {
-          "11091894166229312484": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 20
+          "14514982005979867414": {
+            "error_kind": "string",
+            "string": "attempt to bit-shift with overflow"
           },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
-          "1705275289401561847": {
+          "17618083556256589634": {
             "error_kind": "string",
-            "string": "Mismatch note header storage slot."
+            "string": "Initialization hash does not match"
           },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
+          "2233873454491509486": {
             "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
+            "string": "Initializer address is not the contract deployer"
           },
-          "4939791462094160055": {
+          "2709101749560550278": {
             "error_kind": "string",
-            "string": "Message not authorized by account"
+            "string": "Cannot serialize point at infinity as bytes."
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "3151558035338938026": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              }
+            ],
+            "length": 75
           },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6869395374906889440": {
+          "6485997221020871071": {
             "error_kind": "string",
-            "string": "Mismatch note header contract address."
+            "string": "call to assert_max_bit_size"
           },
           "7233212735005103307": {
             "error_kind": "string",
             "string": "attempt to multiply with overflow"
+          },
+          "8193989641828211937": {
+            "error_kind": "string",
+            "string": "ciphertext length mismatch"
           }
         },
         "parameters": [
@@ -176,7 +275,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -507,6 +606,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -533,7 +653,14 @@
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "name": "signing_pub_key_x",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "signing_pub_key_y",
             "type": {
               "kind": "field"
             },
@@ -1275,7 +1402,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -1606,6 +1733,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -1624,26 +1772,35 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "get_note_internal",
+        "get_contract_instance_internal",
         "decompose_hint",
-        "get_auth_witness",
-        "pack_returns_oracle_wrapper",
-        "directive_invert",
+        "lte_hint",
+        "notify_created_note_oracle_wrapper",
+        "debug_log_oracle_wrapper",
+        "get_random_bytes",
+        "random",
+        "field_less_than",
+        "build_msg_block",
+        "attach_len_to_msg_block",
+        "get_app_tag_as_sender",
+        "increment_app_tagging_secret_index_as_sender_wrapper",
         "directive_integer_quotient",
+        "directive_invert",
         "directive_to_radix"
       ],
-      "verification_key": "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",
-      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-e4cfe2403c455ce8bdee13ac07b713f5-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-329970d418433bc457c8ea0687fd511f-client-ivc-true"
     },
     {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
         "private",
-        "noinitcheck"
+        "noinitcheck",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1664,13 +1821,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"
           },
           "6869395374906889440": {
             "error_kind": "string",
@@ -1786,7 +1947,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -2117,6 +2278,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -2143,173 +2325,9 @@
             "visibility": "private"
           },
           {
-            "name": "app_payload",
+            "name": "inner_hash",
             "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",
-            "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -3049,7 +3067,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -3380,6 +3398,27 @@
                               "kind": "struct",
                               "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                             }
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
                           }
                         ],
                         "kind": "struct",
@@ -3398,125 +3437,193 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_note_internal",
         "decompose_hint",
         "get_auth_witness",
-        "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_invert",
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "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",
-      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-358961913499359414110b453e76a4fe-client-ivc-true"
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-b35a69264b78cb51eaaa8120532a893a-client-ivc-true"
     },
     {
-      "name": "constructor",
-      "is_unconstrained": false,
-      "custom_attributes": [
-        "private",
-        "initializer"
-      ],
+      "name": "lookup_validity",
+      "is_unconstrained": true,
+      "custom_attributes": [],
       "abi": {
         "error_types": {
-          "14514982005979867414": {
-            "error_kind": "string",
-            "string": "attempt to bit-shift with overflow"
-          },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
-          "17618083556256589634": {
-            "error_kind": "string",
-            "string": "Initialization hash does not match"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2233873454491509486": {
+          "16954218183513903507": {
             "error_kind": "string",
-            "string": "Initializer address is not the contract deployer"
+            "string": "Attempted to read past end of BoundedVec"
           },
-          "2429784973622283587": {
+          "17595253152434889169": {
             "error_kind": "string",
-            "string": "Can only emit a note log for an existing note."
+            "string": "offset too large"
           },
-          "2709101749560550278": {
+          "17843811134343075018": {
             "error_kind": "string",
-            "string": "Cannot serialize point at infinity as bytes."
+            "string": "Stack too deep"
           },
           "2920182694213909827": {
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
           },
-          "3151558035338938026": {
-            "error_kind": "fmtstring",
-            "item_types": [
-              {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 32
-              }
-            ],
-            "length": 75
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6485997221020871071": {
+          "5727012404371710682": {
             "error_kind": "string",
-            "string": "call to assert_max_bit_size"
+            "string": "push out of bounds"
           },
           "7233212735005103307": {
             "error_kind": "string",
             "string": "attempt to multiply with overflow"
-          },
-          "8193989641828211937": {
-            "error_kind": "string",
-            "string": "ciphertext length mismatch"
           }
         },
         "parameters": [
           {
-            "name": "inputs",
+            "name": "consumer",
             "type": {
               "fields": [
                 {
-                  "name": "call_context",
+                  "name": "inner",
                   "type": {
-                    "fields": [
-                      {
-                        "name": "msg_sender",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "inner",
-                              "type": {
-                                "kind": "field"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                        }
-                      },
-                      {
-                        "name": "contract_address",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "inner",
-                              "type": {
-                                "kind": "field"
-                              }
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "inner_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "boolean"
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "lookup_validity"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VUyw6CMBBseURBOaiJ3kz8gyIYOJJ49x8akKMe8OKNT5eabbqpVRKlJkzSbEs3szNlW0oUKESPvAH9tGnIFdhBDCA6aN/tRgFr9hviQKs7JH/O0iQw+BtQ/5OfWtIvIPktnT+bAM+xVfzYi6w77UaIesKWZ/nPbHpe9fhc/MFnh32k1caghm+uIYci3RuYR4Y8iRlRd9prh/eV5YzJei7w++RVO67va/lrWIeafvmOFV/qrDMe1wmv+YFXVVrypcYv4KBzGnMvbGHe1wvY45yo3mjul/J0vZ0b0gNB8gCVxsvQjgYAAA==",
+      "debug_symbols": "ndLBCoQgFAXQf3nrFmla2a/EEFYWgliYDQzRv49GMzRDG908vOJ5bu4GvWjXsZF6mBao6g3U1HErJ+3StifQGqmUHJvrNaR+IHS8X2aufVwsNxYqTFACQvf+xJwfpBJQkSzfHwkgHE6ycELCCQ0m+PYXRhA7DSMk/yJE0wPRGJTHoCIGlREou+0Bo2n5QRQXv2h38cmN5K0SZ8+GVXeX2tnXLP4aOJupE/1qhO/ipYZu1qhIMHZr3eo3",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "entrypoint",
+      "is_unconstrained": false,
+      "custom_attributes": [
+        "private",
+        "noinitcheck"
+      ],
+      "abi": {
+        "error_types": {
+          "11091894166229312484": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 20
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "1705275289401561847": {
+            "error_kind": "string",
+            "string": "Mismatch note header storage slot."
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
+          "6869395374906889440": {
+            "error_kind": "string",
+            "string": "Mismatch note header contract address."
+          },
+          "7233212735005103307": {
+            "error_kind": "string",
+            "string": "attempt to multiply with overflow"
+          }
+        },
+        "parameters": [
+          {
+            "name": "inputs",
+            "type": {
+              "fields": [
+                {
+                  "name": "call_context",
+                  "type": {
+                    "fields": [
+                      {
+                        "name": "msg_sender",
+                        "type": {
+                          "fields": [
+                            {
+                              "name": "inner",
+                              "type": {
+                                "kind": "field"
+                              }
+                            }
+                          ],
+                          "kind": "struct",
+                          "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+                        }
+                      },
+                      {
+                        "name": "contract_address",
+                        "type": {
+                          "fields": [
+                            {
+                              "name": "inner",
+                              "type": {
+                                "kind": "field"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -3589,7 +3696,7 @@
                               }
                             },
                             {
-                              "name": "txs_effects_hash",
+                              "name": "blobs_hash",
                               "type": {
                                 "kind": "field"
                               }
@@ -3920,6 +4027,27 @@
                                 "kind": "struct",
                                 "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
                               }
+                            },
+                            {
+                              "name": "max_priority_fees_per_gas",
+                              "type": {
+                                "fields": [
+                                  {
+                                    "name": "fee_per_da_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  },
+                                  {
+                                    "name": "fee_per_l2_gas",
+                                    "type": {
+                                      "kind": "field"
+                                    }
+                                  }
+                                ],
+                                "kind": "struct",
+                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                              }
                             }
                           ],
                           "kind": "struct",
@@ -3946,16 +4074,173 @@
             "visibility": "private"
           },
           {
-            "name": "signing_pub_key_x",
+            "name": "app_payload",
             "type": {
-              "kind": "field"
+              "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": "signing_pub_key_y",
+            "name": "fee_payload",
             "type": {
-              "kind": "field"
+              "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",
+            "type": {
+              "kind": "boolean"
             },
             "visibility": "private"
           }
@@ -4695,7 +4980,7 @@
                             }
                           },
                           {
-                            "name": "txs_effects_hash",
+                            "name": "blobs_hash",
                             "type": {
                               "kind": "field"
                             }
@@ -5026,224 +5311,61 @@
                               "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": "struct",
-            "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs"
-          },
-          "visibility": "databus"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "get_contract_instance_internal",
-        "decompose_hint",
-        "lte_hint",
-        "notify_created_note_oracle_wrapper",
-        "debug_log_oracle_wrapper",
-        "get_random_bytes",
-        "random",
-        "field_less_than",
-        "build_msg_block",
-        "attach_len_to_msg_block",
-        "get_app_tag_as_sender",
-        "increment_app_tagging_secret_index_as_sender_wrapper",
-        "directive_integer_quotient",
-        "directive_invert",
-        "directive_to_radix"
-      ],
-      "verification_key": "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",
-      "artifact_hash": "ff6671ddb572df3d961df43ed4c3adf75a7d3763-79d40c8395c9a0c28cc94c6923ec1838-client-ivc-true"
-    },
-    {
-      "name": "lookup_validity",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "16954218183513903507": {
-            "error_kind": "string",
-            "string": "Attempted to read past end of BoundedVec"
-          },
-          "17595253152434889169": {
-            "error_kind": "string",
-            "string": "offset too large"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "7233212735005103307": {
-            "error_kind": "string",
-            "string": "attempt to multiply with overflow"
-          }
-        },
-        "parameters": [
-          {
-            "name": "consumer",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "inner_hash",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "boolean"
-          },
-          "visibility": "public"
-        }
-      },
-      "bytecode": "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",
-      "debug_symbols": "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",
-      "brillig_names": [
-        "lookup_validity"
-      ]
-    },
-    {
-      "name": "compute_note_hash_and_optionally_a_nullifier",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "11091894166229312484": {
-            "error_kind": "fmtstring",
-            "item_types": [],
-            "length": 20
-          },
-          "16761564377371454734": {
-            "error_kind": "string",
-            "string": "Array index out of bounds"
-          },
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          },
-          "5019202896831570965": {
-            "error_kind": "string",
-            "string": "attempt to add with overflow"
-          },
-          "8270195893599566439": {
-            "error_kind": "string",
-            "string": "Invalid public keys hint for address"
-          }
-        },
-        "parameters": [
-          {
-            "name": "contract_address",
-            "type": {
-              "fields": [
-                {
-                  "name": "inner",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "compute_nullifier",
-            "type": {
-              "kind": "boolean"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "serialized_note",
-            "type": {
-              "kind": "array",
-              "length": 3,
-              "type": {
-                "kind": "field"
+                          },
+                          {
+                            "name": "max_priority_fees_per_gas",
+                            "type": {
+                              "fields": [
+                                {
+                                  "name": "fee_per_da_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                },
+                                {
+                                  "name": "fee_per_l2_gas",
+                                  "type": {
+                                    "kind": "field"
+                                  }
+                                }
+                              ],
+                              "kind": "struct",
+                              "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
+                            }
+                          }
+                        ],
+                        "kind": "struct",
+                        "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
+                      }
+                    }
+                  ],
+                  "kind": "struct",
+                  "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
+                }
               }
-            },
-            "visibility": "private"
-          }
-        ],
-        "return_type": {
-          "abi_type": {
-            "kind": "array",
-            "length": 4,
-            "type": {
-              "kind": "field"
-            }
+            ],
+            "kind": "struct",
+            "path": "authwit::aztec::protocol_types::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs"
           },
-          "visibility": "public"
+          "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": [
-        "compute_note_hash_and_optionally_a_nullifier"
-      ]
+        "get_note_internal",
+        "decompose_hint",
+        "get_auth_witness",
+        "enqueue_public_function_call_internal",
+        "call_private_function_internal",
+        "debug_log_oracle_wrapper",
+        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
+        "directive_invert",
+        "directive_integer_quotient",
+        "directive_to_radix"
+      ],
+      "verification_key": "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",
+      "artifact_hash": "e7552d296af009c9ed2e2ca261de6124cad0b1c1-b35a7e82017c45a8b08b8597d78847b9-client-ivc-true"
     }
   ],
   "outputs": {
@@ -5406,33 +5528,6 @@
           "kind": "struct",
           "path": "SchnorrAccount::verify_private_authwit_abi"
         },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "signing_pub_key_x",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "signing_pub_key_y",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrAccount::constructor_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrAccount::constructor_abi"
-        },
         {
           "fields": [
             {
@@ -5615,15 +5710,38 @@
           ],
           "kind": "struct",
           "path": "SchnorrAccount::entrypoint_abi"
+        },
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "signing_pub_key_x",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "signing_pub_key_y",
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "SchnorrAccount::constructor_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "SchnorrAccount::constructor_abi"
         }
       ]
     }
   },
   "file_map": {
-    "3": {
-      "path": "std/array/mod.nr",
-      "source": "use crate::cmp::{Eq, Ord};\nuse crate::convert::From;\nuse crate::runtime::is_unconstrained;\n\nmod check_shuffle;\nmod quicksort;\n\nimpl<T, let N: u32> [T; N] {\n    /// Returns the length of this array.\n    ///\n    /// ```noir\n    /// fn len(self) -> Field\n    /// ```\n    ///\n    /// example\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let array = [42, 42];\n    ///     assert(array.len() == 2);\n    /// }\n    /// ```\n    #[builtin(array_len)]\n    pub fn len(self) -> u32 {}\n\n    /// Returns this array as a slice.\n    ///\n    /// ```noir\n    /// let array = [1, 2];\n    /// let slice = array.as_slice();\n    /// assert_eq(slice, &[1, 2]);\n    /// ```\n    #[builtin(as_slice)]\n    pub fn as_slice(self) -> [T] {}\n\n    /// Applies a function to each element of this array, returning a new array containing the mapped elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// let a = [1, 2, 3];\n    /// let b = a.map(|a| a * 2);\n    /// assert_eq(b, [2, 4, 6]);\n    /// ```\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U; N] {\n        let uninitialized = crate::mem::zeroed();\n        let mut ret = [uninitialized; N];\n\n        for i in 0..self.len() {\n            ret[i] = f(self[i]);\n        }\n\n        ret\n    }\n\n    /// Applies a function to each element of the array, returning the final accumulated value. The first\n    /// parameter is the initial value.\n    ///\n    /// This is a left fold, so the given function will be applied to the accumulator and first element of\n    /// the array, then the second, and so on. For a given call the expected result would be equivalent to:\n    ///\n    /// ```rust\n    /// let a1 = [1];\n    /// let a2 = [1, 2];\n    /// let a3 = [1, 2, 3];\n    ///\n    /// let f = |a, b| a - b;\n    /// a1.fold(10, f); //=> f(10, 1)\n    /// a2.fold(10, f); //=> f(f(10, 1), 2)\n    /// a3.fold(10, f); //=> f(f(f(10, 1), 2), 3)\n    ///\n    /// assert_eq(a3.fold(10, f), 10 - 1 - 2 - 3);\n    /// ```\n    pub fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U {\n        for elem in self {\n            accumulator = f(accumulator, elem);\n        }\n        accumulator\n    }\n\n    /// Same as fold, but uses the first element as the starting element.\n    ///\n    /// Requires the input array to be non-empty.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [1, 2, 3, 4];\n    ///     let reduced = arr.reduce(|a, b| a + b);\n    ///     assert(reduced == 10);\n    /// }\n    /// ```\n    pub fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T {\n        let mut accumulator = self[0];\n        for i in 1..self.len() {\n            accumulator = f(accumulator, self[i]);\n        }\n        accumulator\n    }\n\n    /// Returns true if all the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 2];\n    ///     let all = arr.all(|a| a == 2);\n    ///     assert(all);\n    /// }\n    /// ```\n    pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = true;\n        for elem in self {\n            ret &= predicate(elem);\n        }\n        ret\n    }\n\n    /// Returns true if any of the elements in this array satisfy the given predicate.\n    ///\n    /// Example:\n    ///\n    /// ```noir\n    /// fn main() {\n    ///     let arr = [2, 2, 2, 2, 5];\n    ///     let any = arr.any(|a| a == 5);\n    ///     assert(any);\n    /// }\n    /// ```\n    pub fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool {\n        let mut ret = false;\n        for elem in self {\n            ret |= predicate(elem);\n        }\n        ret\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Ord + Eq,\n{\n    /// Returns a new sorted array. The original array remains untouched. Notice that this function will\n    /// only work for arrays of fields or integers, not for any arbitrary type. This is because the sorting\n    /// logic it uses internally is optimized specifically for these values. If you need a sort function to\n    /// sort any type, you should use the `sort_via` function.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32];\n    ///     let sorted = arr.sort();\n    ///     assert(sorted == [32, 42]);\n    /// }\n    /// ```\n    pub fn sort(self) -> Self {\n        self.sort_via(|a: T, b: T| a <= b)\n    }\n}\n\nimpl<T, let N: u32> [T; N]\nwhere\n    T: Eq,\n{\n    /// Returns a new sorted array by sorting it with a custom comparison function.\n    /// The original array remains untouched.\n    /// The ordering function must return true if the first argument should be sorted to be before the second argument or is equal to the second argument.\n    ///\n    /// Using this method with an operator like `<` that does not return `true` for equal values will result in an assertion failure for arrays with equal elements.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let arr = [42, 32]\n    ///     let sorted_ascending = arr.sort_via(|a, b| a <= b);\n    ///     assert(sorted_ascending == [32, 42]); // verifies\n    ///\n    ///     let sorted_descending = arr.sort_via(|a, b| a >= b);\n    ///     assert(sorted_descending == [32, 42]); // does not verify\n    /// }\n    /// ```\n    pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {\n        unsafe {\n            // Safety: `sorted` array is checked to be:\n            //   a. a permutation of `input`'s elements\n            //   b. satisfying the predicate `ordering`\n            let sorted = quicksort::quicksort(self, ordering);\n\n            if !is_unconstrained() {\n                for i in 0..N - 1 {\n                    assert(\n                        ordering(sorted[i], sorted[i + 1]),\n                        \"Array has not been sorted correctly according to `ordering`.\",\n                    );\n                }\n                check_shuffle::check_shuffle(self, sorted);\n            }\n            sorted\n        }\n    }\n}\n\nimpl<let N: u32> [u8; N] {\n    /// Converts a byte array of type `[u8; N]` to a string. Note that this performs no UTF-8 validation -\n    /// the given array is interpreted as-is as a string.\n    ///\n    /// Example:\n    ///\n    /// ```rust\n    /// fn main() {\n    ///     let hi = [104, 105].as_str_unchecked();\n    ///     assert_eq(hi, \"hi\");\n    /// }\n    /// ```\n    #[builtin(array_as_str_unchecked)]\n    pub fn as_str_unchecked(self) -> str<N> {}\n}\n\nimpl<let N: u32> From<str<N>> for [u8; N] {\n    /// Returns an array of the string bytes.\n    fn from(s: str<N>) -> Self {\n        s.as_bytes()\n    }\n}\n\nmod test {\n    #[test]\n    fn map_empty() {\n        assert_eq([].map(|x| x + 1), []);\n    }\n}\n"
-    },
     "6": {
       "path": "std/cmp.nr",
       "source": "use crate::meta::derive_via;\n\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: StructDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for u1 {\n    fn eq(self, other: u1) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\nimpl<A, B> Eq for (A, B)\nwhere\n    A: Eq,\n    B: Eq,\n{\n    fn eq(self, other: (A, B)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1)\n    }\n}\n\nimpl<A, B, C> Eq for (A, B, C)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n{\n    fn eq(self, other: (A, B, C)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2)\n    }\n}\n\nimpl<A, B, C, D> Eq for (A, B, C, D)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n{\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        self.0.eq(other.0) & self.1.eq(other.1) & self.2.eq(other.2) & self.3.eq(other.3)\n    }\n}\n\nimpl<A, B, C, D, E> Eq for (A, B, C, D, E)\nwhere\n    A: Eq,\n    B: Eq,\n    C: Eq,\n    D: Eq,\n    E: Eq,\n{\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        self.0.eq(other.0)\n            & self.1.eq(other.1)\n            & self.2.eq(other.2)\n            & self.3.eq(other.3)\n            & self.4.eq(other.4)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: StructDefinition) -> Quoted {\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> std::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == std::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = std::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, quote { Ord }, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let mut result = self.len().cmp(other.len());\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                let result_i = self[i].cmp(other[i]);\n\n                if result_i == Ordering::less() {\n                    result = result_i;\n                } else if result_i == Ordering::greater() {\n                    result = result_i;\n                }\n            }\n        }\n        result\n    }\n}\n\nimpl<A, B> Ord for (A, B)\nwhere\n    A: Ord,\n    B: Ord,\n{\n    fn cmp(self, other: (A, B)) -> Ordering {\n        let result = self.0.cmp(other.0);\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self.1.cmp(other.1)\n        }\n    }\n}\n\nimpl<A, B, C> Ord for (A, B, C)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n{\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D> Ord for (A, B, C, D)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n{\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        result\n    }\n}\n\nimpl<A, B, C, D, E> Ord for (A, B, C, D, E)\nwhere\n    A: Ord,\n    B: Ord,\n    C: Ord,\n    D: Ord,\n    E: Ord,\n{\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        let mut result = self.0.cmp(other.0);\n\n        if result == Ordering::equal() {\n            result = self.1.cmp(other.1);\n        }\n\n        if result == Ordering::equal() {\n            result = self.2.cmp(other.2);\n        }\n\n        if result == Ordering::equal() {\n            result = self.3.cmp(other.3);\n        }\n\n        if result == Ordering::equal() {\n            result = self.4.cmp(other.4);\n        }\n\n        result\n    }\n}\n\n// Compares and returns the maximum of two values.\n//\n// Returns the second argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::max(1, 2), 2);\n// assert_eq(cmp::max(2, 2), 2);\n// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n// Compares and returns the minimum of two values.\n//\n// Returns the first argument if the comparison determines them to be equal.\n//\n// # Examples\n//\n// ```\n// use std::cmp;\n//\n// assert_eq(cmp::min(1, 2), 1);\n// assert_eq(cmp::min(2, 2), 2);\n// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use crate::cmp::{max, min};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0 as u64, 1 as u64), 0);\n        assert_eq(min(0 as u64, 0 as u64), 0);\n        assert_eq(min(1 as u64, 1 as u64), 1);\n        assert_eq(min(255 as u8, 0 as u8), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0 as u64, 1 as u64), 1);\n        assert_eq(max(0 as u64, 0 as u64), 0);\n        assert_eq(max(1 as u64, 1 as u64), 1);\n        assert_eq(max(255 as u8, 0 as u8), 255);\n    }\n}\n"
@@ -5665,194 +5783,194 @@
       "source": "pub fn panic<T, U, let N: u32>(message: fmtstr<N, T>) -> U {\n    assert(false, message);\n    crate::mem::zeroed()\n}\n"
     },
     "66": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
+      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n/// ```\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
+    },
+    "71": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/point.nr",
+      "source": "use dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a public key to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(pk: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!pk.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = pk.x.to_be_bytes();\n\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    if !BN254_FR_MODULUS_DIV_2.lt(pk.y) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\nmod test {\n    use crate::utils::point::point_to_bytes;\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n}\n"
+    },
+    "77": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/private_immutable.nr",
+      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize},\n};\n\nuse crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n    lifecycle::create_note,\n    note_emission::NoteEmission,\n    note_getter::{get_note, view_notes},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n};\nuse crate::oracle::notes::check_nullifier_exists;\nuse crate::state_vars::storage::Storage;\n\n// docs:start:struct\npub struct PrivateImmutable<Note, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PrivateImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<Note, Context> PrivateImmutable<Note, Context> {\n    // docs:start:new\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n    // docs:end:new\n\n    // The following computation is leaky, in that it doesn't hide the storage slot that has been initialized, nor does it hide the contract address of this contract.\n    // When this initialization nullifier is emitted, an observer could do a dictionary or rainbow attack to learn the preimage of this nullifier to deduce the storage slot and contract address.\n    // For some applications, leaking the details that a particular state variable of a particular contract has been initialized will be unacceptable.\n    // Under such circumstances, such application developers might wish to _not_ use this state variable type.\n    // This is especially dangerous for initial assignment to elements of a `Map<AztecAddress, PrivateImmutable>` type (for example), because the storage slot often also identifies an actor.\n    // e.g. the initial assignment to `my_map.at(msg.sender)` will leak: `msg.sender`, the fact that an element of `my_map` was assigned-to for the first time, and the contract_address.\n    pub fn compute_initialization_nullifier(self) -> Field {\n        poseidon2_hash_with_separator(\n            [self.storage_slot],\n            GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n        )\n    }\n}\n\nimpl<Note> PrivateImmutable<Note, &mut PrivateContext> {\n    // docs:start:initialize\n    pub fn initialize<let N: u32>(self, note: &mut Note) -> NoteEmission<Note>\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        // Nullify the storage slot.\n        let nullifier = self.compute_initialization_nullifier();\n        self.context.push_nullifier(nullifier);\n\n        create_note(self.context, self.storage_slot, note)\n    }\n    // docs:end:initialize\n\n    // docs:start:get_note\n    pub fn get_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let storage_slot = self.storage_slot;\n        get_note(self.context, storage_slot).0\n    }\n    // docs:end:get_note\n}\n\nimpl<Note> PrivateImmutable<Note, UnconstrainedContext> {\n    // docs:start:is_initialized\n    pub unconstrained fn is_initialized(self) -> bool {\n        let nullifier = self.compute_initialization_nullifier();\n        check_nullifier_exists(nullifier)\n    }\n    // docs:end:is_initialized\n\n    // view_note does not actually use the context, but it calls oracles that are only available in private\n    // docs:start:view_note\n    pub unconstrained fn view_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let mut options = NoteViewerOptions::new();\n        view_notes(self.storage_slot, options.set_limit(1)).get(0)\n    }\n    // docs:end:view_note\n}\n"
     },
-    "70": {
+    "93": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/unconstrained_context.nr",
       "source": "use crate::oracle::{\n    execution::{get_block_number, get_chain_id, get_contract_address, get_version},\n    storage::storage_read,\n};\nuse dep::protocol_types::{address::AztecAddress, traits::Deserialize};\n\npub struct UnconstrainedContext {\n    block_number: u32,\n    contract_address: AztecAddress,\n    version: Field,\n    chain_id: Field,\n}\n\nimpl UnconstrainedContext {\n    pub unconstrained fn new() -> Self {\n        // We could call these oracles on the getters instead of at creation, which makes sense given that they might\n        // not even be accessed. However any performance gains are minimal, and we'd rather fail early if a user\n        // incorrectly attempts to create an UnconstrainedContext in an environment in which these oracles are not\n        // available.\n        let block_number = get_block_number();\n        let contract_address = get_contract_address();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at(contract_address: AztecAddress) -> Self {\n        let block_number = get_block_number();\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub unconstrained fn at_historical(contract_address: AztecAddress, block_number: u32) -> Self {\n        let chain_id = get_chain_id();\n        let version = get_version();\n        Self { block_number, contract_address, version, chain_id }\n    }\n\n    pub fn block_number(self) -> u32 {\n        self.block_number\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.contract_address\n    }\n\n    pub fn version(self) -> Field {\n        self.version\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.chain_id\n    }\n\n    pub unconstrained fn raw_storage_read<let N: u32>(\n        self: Self,\n        storage_slot: Field,\n    ) -> [Field; N] {\n        storage_read(self.this_address(), storage_slot, self.block_number())\n    }\n\n    pub unconstrained fn storage_read<T, let N: u32>(self, storage_slot: Field) -> T\n    where\n        T: Deserialize<N>,\n    {\n        T::deserialize(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
-    "76": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/generators.nr",
-      "source": "use dep::protocol_types::point::Point;\n\n// A set of generators generated with `derive_generators(...)` function from noir::std\npub global Ga1: Point = Point {\n    x: 0x30426e64aee30e998c13c8ceecda3a77807dbead52bc2f3bf0eae851b4b710c1,\n    y: 0x113156a068f603023240c96b4da5474667db3b8711c521c748212a15bc034ea6,\n    is_infinite: false,\n};\npub global Ga2: Point = Point {\n    x: 0x2825c79cc6a5cbbeef7d6a8f1b6a12b312aa338440aefeb4396148c89147c049,\n    y: 0x129bfd1da54b7062d6b544e7e36b90736350f6fba01228c41c72099509f5701e,\n    is_infinite: false,\n};\npub global Ga3: Point = Point {\n    x: 0x0edb1e293c3ce91bfc04e3ceaa50d2c541fa9d091c72eb403efb1cfa2cb3357f,\n    y: 0x1341d675fa030ece3113ad53ca34fd13b19b6e9762046734f414824c4d6ade35,\n    is_infinite: false,\n};\npub global Ga4: Point = Point {\n    x: 0x0e0dad2250583f2a9f0acb04ededf1701b85b0393cae753fe7e14b88af81cb52,\n    y: 0x0973b02c5caac339ee4ad5dab51329920f7bf1b6a07e1dabe5df67040b300962,\n    is_infinite: false,\n};\npub global Ga5: Point = Point {\n    x: 0x2f3342e900e8c488a28931aae68970738fdc68afde2910de7b320c00c902087d,\n    y: 0x1bf958dc63cb09d59230603a0269ae86d6f92494da244910351f1132df20fc08,\n    is_infinite: false,\n};\n// If you change this update `G_SLOT` in `yarn-project/simulator/src/client/test_utils.ts` as well\npub global G_slot: Point = Point {\n    x: 0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15,\n    y: 0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791,\n    is_infinite: false,\n};\n\nmod test {\n    use crate::generators::{G_slot, Ga1, Ga2, Ga3, Ga4, Ga5};\n    use dep::protocol_types::point::Point;\n    use std::hash::derive_generators;\n\n    #[test]\n    unconstrained fn test_generators() {\n        let generators: [Point; 6] = derive_generators(\"aztec_nr_generators\".as_bytes(), 0);\n        assert_eq(generators[0], Ga1);\n        assert_eq(generators[1], Ga2);\n        assert_eq(generators[2], Ga3);\n        assert_eq(generators[4], Ga4);\n        assert_eq(generators[5], Ga5);\n        assert_eq(generators[3], G_slot);\n    }\n}\n"
+    "98": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, packed_returns::PackedReturns},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        arguments,\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        key_validation_request::get_key_validation_request,\n        returns::pack_returns,\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: self.next_counter(),\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        pack_returns(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert(request.pk_m.hash() == pk_m_hash);\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> PackedReturns {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_private_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> PackedReturns {\n        self.call_private_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> PackedReturns {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // The oracle simulates the private call and returns the value of the side effects counter after execution of\n        // the call (which means that end_side_effect_counter - start_side_effect_counter is the number of side effects\n        // that took place), along with the hash of the return values. We validate these by requesting a private kernel\n        // iteration in which the return values are constrained to hash to `returns_hash` and the side effects counter\n        // to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        PackedReturns::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.call_public_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_packed_args(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = enqueue_public_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        arguments::pack_arguments_array(args);\n        self.set_public_teardown_function_with_packed_args(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_packed_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle repacks the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = set_public_teardown_function_call_internal(\n            contract_address,\n            function_selector,\n            args_hash,\n            counter,\n            is_static_call,\n        );\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
-    "77": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/keys.nr",
-      "source": "use dep::protocol_types::{\n    address::{AztecAddress, PartialAddress},\n    point::Point,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n    let result = get_public_keys_and_partial_address_oracle(address);\n\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n        ivpk_m: IvpkM {\n            inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n        },\n        ovpk_m: OvpkM {\n            inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n        },\n        tpk_m: TpkM {\n            inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(result[12]);\n\n    (keys, partial_address)\n}\n"
+    "100": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    point::Point,\n    public_keys::{IvpkM, ToPoint},\n    scalar::Scalar,\n};\n\nuse crate::keys::secret_derivation::derive_aes_secret;\n\nuse std::aes128::aes128_encrypt;\n\npub struct EncryptedLogHeader {\n    address: AztecAddress,\n}\n\nimpl EncryptedLogHeader {\n    pub fn new(address: AztecAddress) -> Self {\n        EncryptedLogHeader { address }\n    }\n\n    pub fn compute_ciphertext<T>(self, secret: Scalar, pk: T) -> [u8; 48]\n    where\n        T: ToPoint,\n    {\n        let full_key = derive_aes_secret(secret, pk.to_point());\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n\n        for i in 0..16 {\n            sym_key[i] = full_key[i];\n            iv[i] = full_key[i + 16];\n        }\n\n        let input: [u8; 32] = self.address.to_field().to_be_bytes();\n        aes128_encrypt(input, iv, sym_key).as_array()\n    }\n}\n\n#[test]\nunconstrained fn test_encrypted_log_header_matches_noir() {\n    let address = AztecAddress::from_field(0xdeadbeef);\n    let header = EncryptedLogHeader::new(address);\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = IvpkM {\n        inner: Point {\n            x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n            y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n            is_infinite: false,\n        },\n    };\n\n    let ciphertext = header.compute_ciphertext(secret, point);\n\n    // The following value was generated by `encrypted_log_header.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_header_ciphertext_from_typescript = [\n        226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 194, 44, 7, 131,\n        160, 83, 64, 181, 98, 38, 153, 214, 62, 171, 253, 161, 111, 191, 28, 247, 216, 26, 222, 171,\n        176, 218, 48, 209, 73, 89, 200, 209,\n    ];\n\n    assert_eq(ciphertext, expected_header_ciphertext_from_typescript);\n}\n"
+    },
+    "103": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr",
+      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{GENERATOR_INDEX__SYMMETRIC_KEY, PRIVATE_LOG_SIZE_IN_FIELDS},\n    hash::poseidon2_hash,\n    point::Point,\n    public_keys::AddressPoint,\n    scalar::Scalar,\n    utils::arrays::array_concat,\n};\nuse std::{\n    aes128::aes128_encrypt, embedded_curve_ops::fixed_base_scalar_mul as derive_public_key,\n    field::bn254::decompose, hash::from_field_unsafe as fr_to_fq_unsafe,\n};\n\nuse crate::{\n    encrypted_logs::header::EncryptedLogHeader,\n    keys::secret_derivation::derive_aes_secret,\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::bytes_to_fields, point::point_to_bytes},\n};\n\n// 1 field is reserved for tag.\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n\ncomptime global HEADER_SIZE: u32 = 48;\n\n// Bytes padded to the overhead, so that the size of the incoming body ciphertext will be a multiple of 16.\ncomptime global OVERHEAD_PADDING: u32 = 15;\n\npub comptime global OVERHEAD_SIZE: u32 = 32 /* eph_pk */\n    + HEADER_SIZE /* incoming_header */\n    + OVERHEAD_PADDING /* padding */;\n\nglobal PLAINTEXT_LENGTH_SIZE: u32 = 2;\n\n// This is enough for 8 fields of data.\n// 1 field for storage slot, 1 field for note/event type id, allowing 6 fields for custom values.\nglobal MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n    ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\n// Note: Might have to update PRIVATE_LOG_SIZE_IN_FIELDS in `constants.nr` if the above changes.\n// This value ideally should be set by the protocol, allowing users (or `aztec-nr`) to fit data within the defined size limits.\n// Currently, we adjust this value as the structure changes, then update `constants.nr` to match.\n// Once the structure is finalized with defined overhead and max note field sizes, this value will be fixed and should remain unaffected by further payload composition changes.\n\npub fn compute_private_log_payload<let P: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n    assert(\n        P < MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n        f\"plaintext for log must not exceed {MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES}\",\n    );\n\n    let extended_plaintext: [u8; MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n    array_concat([tag], bytes_to_fields(encrypted))\n}\n\npub fn compute_partial_public_log_payload<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let extended_plaintext: [u8; P + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; M - 32] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n    // Silo the tag with contract address.\n    // This is done by the kernel circuit to the private logs, but since the partial log will be finalized and emitted\n    // in public as unencrypted log, its tag is not siloed at the moment.\n    // To avoid querying logs using two types of tags, we silo the tag manually here.\n    // TODO(#10273) This should be done by the AVM when it's processing the raw logs instead of their hashes.\n    let siloed_tag_bytes: [u8; 32] =\n        poseidon2_hash([contract_address.to_field(), tag]).to_be_bytes();\n\n    // Temporary hack so that the partial public log remains the same format.\n    // It should return field array and make the tag the first field as compute_private_log_payload does.\n    let mut log_bytes = [0; M];\n    for i in 0..32 {\n        log_bytes[i] = siloed_tag_bytes[i];\n    }\n    for i in 0..encrypted.len() {\n        log_bytes[i + 32] = encrypted[i];\n    }\n\n    log_bytes\n}\n\nfn compute_encrypted_log<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let header = EncryptedLogHeader::new(contract_address);\n\n    let incoming_header_ciphertext: [u8; 48] =\n        header.compute_ciphertext(eph_sk, recipient.to_address_point());\n    let incoming_body_ciphertext =\n        compute_incoming_body_ciphertext(plaintext, eph_sk, recipient.to_address_point());\n\n    let mut encrypted_bytes = [0; M];\n    let mut offset = 0;\n\n    // eph_pk\n    let eph_pk_bytes = point_to_bytes(eph_pk);\n    for i in 0..32 {\n        encrypted_bytes[offset + i] = eph_pk_bytes[i];\n    }\n    offset += 32;\n\n    // incoming_header\n    for i in 0..HEADER_SIZE {\n        encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n    }\n    offset += HEADER_SIZE;\n\n    // Padding.\n    offset += OVERHEAD_PADDING;\n\n    // incoming_body\n    // Then we fill in the rest as the incoming body ciphertext\n    let size = M - offset;\n    assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n    for i in 0..size {\n        encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n    }\n\n    encrypted_bytes\n}\n\n// Prepend the plaintext length as the first byte, then copy the plaintext itself starting from the second byte.\n// Fill the remaining bytes with random values to reach a fixed length of N.\nfn extend_private_log_plaintext<let P: u32, let N: u32>(plaintext: [u8; P]) -> [u8; N] {\n    let mut padded = unsafe { get_random_bytes() };\n    padded[0] = (P >> 8) as u8;\n    padded[1] = P as u8;\n    for i in 0..P {\n        padded[i + PLAINTEXT_LENGTH_SIZE] = plaintext[i];\n    }\n    padded\n}\n\nunconstrained fn get_random_bytes<let N: u32>() -> [u8; N] {\n    let mut bytes = [0; N];\n    let mut idx = 32;\n    let mut randomness = [0; 32];\n    for i in 0..N {\n        if idx == 32 {\n            randomness = random().to_be_bytes();\n            idx = 1; // Skip the first byte as it's always 0.\n        }\n        bytes[i] = randomness[idx];\n        idx += 1;\n    }\n    bytes\n}\n\n/// Converts a base field element to scalar field element.\n/// This is fine because modulus of the base field is smaller than the modulus of the scalar field.\nfn fr_to_fq(r: Field) -> Scalar {\n    let (lo, hi) = decompose(r);\n\n    Scalar { lo, hi }\n}\n\nfn generate_ephemeral_key_pair() -> (Scalar, Point) {\n    // @todo Need to draw randomness from the full domain of Fq not only Fr\n    // We use the randomness to preserve the privacy of both the sender and recipient via encryption, so a malicious\n    // sender could use non-random values to reveal the plaintext. But they already know it themselves anyway, and so\n    // the recipient already trusts them to not disclose this information. We can therefore assume that the sender will\n    // cooperate in the random value generation.\n    let randomness = unsafe { random() };\n\n    // We use the unsafe version of `fr_to_fq` because multi_scalar_mul (called by derive_public_key) will constrain\n    // the scalars.\n    let eph_sk = fr_to_fq_unsafe(randomness);\n    let eph_pk = derive_public_key(eph_sk);\n\n    (eph_sk, eph_pk)\n}\n\npub fn compute_incoming_body_ciphertext<let P: u32>(\n    plaintext: [u8; P],\n    eph_sk: Scalar,\n    address_point: AddressPoint,\n) -> [u8] {\n    let full_key = derive_aes_secret(eph_sk, address_point.to_point());\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n\n    for i in 0..16 {\n        sym_key[i] = full_key[i];\n        iv[i] = full_key[i + 16];\n    }\n    aes128_encrypt(plaintext, iv, sym_key)\n}\n\nmod test {\n    use crate::encrypted_logs::payload::{\n        compute_incoming_body_ciphertext, compute_private_log_payload,\n        MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n    };\n    use dep::protocol_types::{address::AztecAddress, point::Point, scalar::Scalar};\n    use protocol_types::public_keys::AddressPoint;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_log_payload.test.ts`\n        let contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        );\n\n        let plaintext = [\n            0, 0, 0, 1, 48, 22, 64, 206, 234, 117, 131, 145, 178, 225, 97, 201, 44, 5, 19, 241, 41,\n            2, 15, 65, 37, 37, 106, 253, 174, 38, 70, 206, 49, 9, 159, 92, 16, 244, 140, 217, 239,\n            247, 174, 91, 32, 156, 85, 124, 112, 222, 46, 101, 126, 231, 145, 102, 134, 134, 118,\n            183, 135, 233, 65, 126, 25, 38, 14, 4, 15, 228, 107, 229, 131, 183, 31, 74, 181, 183,\n            12, 38, 87, 255, 29, 5, 204, 207, 29, 41, 42, 147, 105, 98, 141, 26, 25, 79, 148, 78,\n            101, 153, 0, 0, 16, 39,\n        ];\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(\n            (MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES as u64 + 1 + 30) / 31,\n        );\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let sender = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let _ = OracleMock::mock(\"getIndexedTaggingSecretAsSender\").returns([69420, 1337]);\n\n        let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n        let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n        // The following value was generated by `encrypted_log_payload.test.ts`\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let private_log_payload_from_typescript = [\n            0x0e9cffc3ddd746affb02410d8f0a823e89939785bcc8e88ee4f3cae05e737c36,\n            0x008d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701f,\n            0x00a70577790aeabcc2d81ec8d0c99e7f5d2bf2f1452025dc777a178404f851d9,\n            0x003de818923f85187871d99bdf95d695eff0a900000000000000000000000000,\n            0x000000a600a61f7d59eeaf52eb51bc0592ff981d9ba3ea8e6ea8ba9dc0cec8c7,\n            0x000b81e84556a77ce6c3ca47a527f99ffe7b2524bb885a23020b7295748ad19c,\n            0x001083618ad96298b76ee07eb1a56d19cc798710e9f5de96501bd59b3781c9c0,\n            0x002a6c95c5912f8936b1500d362afbf0922c85b1ada18db8b95162a6e9d06765,\n            0x005cdf669eb387f8e0492a95fdcdb39429d5340b4bebc250ba9bf62c2f49f549,\n            0x00f37beed75a668aa51967e0e57547e5a655157bcf381e22f30e25881548ec96,\n            0x0006a151b5fbfb2d14ee4b34bf4c1dbd71c7be15ad4c63474bb6f89970aeb3d9,\n            0x00489c8edbdff80a1a3a5c28370e534abc870a85ea4318326ea19222fb10df35,\n            0x008c765edada497db4284ae30507a2e03e983d23cfa0bd831577e857bbef9cf7,\n            0x0090c97cb5699cc8783a1b4276d929be2882e5b9b72829a4f8404f7e3c853d11,\n            0x00d6d5a000b80134891e95f81007ad35d3945eaeecbe137fff85d01d7eaf8f19,\n            0x00a15eb965c6a4bc97aa87fd3463c31c9d4e0d722a8ba870bcc50c9c7a8b48ad,\n            0x0063c861bdbe490d44c57382decbae663927909652f87ac18dcfd5b30649cce5,\n            0x00820f14caa725efe1fa3485ceac88499eadf0565c5b20998c05931bbf478e68,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n\n    #[test]\n    fn test_incoming_body_ciphertext_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_note_log_incoming_body.test.ts`\n        let eph_sk = Scalar {\n            lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n            hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n        };\n        let address_point = AddressPoint {\n            inner: Point {\n                x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n                y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n                is_infinite: false,\n            },\n        };\n        let plaintext = [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,\n        ];\n\n        // `compute_incoming_body_ciphertext(...)` function then derives symmetric key from `eph_sk` and `address_point` and encrypts\n        // the note plaintext using AES-128.\n        let ciphertext = compute_incoming_body_ciphertext(plaintext, eph_sk, address_point);\n\n        // The following value was generated by `encrypted_note_log_incoming_body.test.ts`.\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let note_body_ciphertext_from_typescript = [\n            226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 147, 228, 160,\n            190, 146, 61, 95, 203, 124, 153, 68, 168, 17, 150, 92, 0, 99, 214, 85, 64, 191, 78, 157,\n            131, 149, 96, 236, 253, 96, 172, 157, 30, 27, 176, 228, 74, 242, 190, 138, 48, 33, 93,\n            46, 37, 223, 130, 25, 245, 188, 163, 159, 223, 187, 24, 139, 206, 131, 154, 159, 130,\n            37, 17, 158, 114, 242, 141, 124, 193, 232, 54, 146, 96, 145, 100, 125, 234, 57, 43, 95,\n            115, 183, 39, 121, 232, 134, 229, 148, 25, 46, 77, 87, 127, 95, 7, 77, 188, 37, 234,\n            245, 142, 232, 87, 252, 28, 67, 67, 90, 214, 254, 89, 47, 68, 66, 187, 227, 8, 59, 162,\n            25, 141, 97, 141, 217, 197, 115, 15, 212, 202, 157, 41, 150, 62, 219, 57, 224, 92, 185,\n            212, 142, 94, 146, 41, 178, 145, 68, 169, 23, 185, 206, 138, 70, 47, 176, 210, 165, 236,\n            23, 206, 229, 108,\n        ];\n\n        assert_eq(note_body_ciphertext_from_typescript.len(), ciphertext.len());\n\n        for i in 0..note_body_ciphertext_from_typescript.len() {\n            assert_eq(ciphertext[i], note_body_ciphertext_from_typescript[i]);\n        }\n    }\n}\n"
+    },
+    "104": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypted_note_emission.nr",
+      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::payload::compute_private_log_payload,\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n};\n\n/// Computes private note log payload\nfn compute_payload<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\n    let storage_slot = note_header.storage_slot;\n\n    // TODO(#8589): use typesystem to skip this check when not needed\n    let note_exists =\n        context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n    assert(note_exists, \"Can only emit a note log for an existing note.\");\n\n    let contract_address: AztecAddress = context.this_address();\n\n    let plaintext = note.to_be_bytes(storage_slot);\n\n    let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n    (payload, note_hash_counter)\n}\n\nunconstrained fn compute_payload_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    compute_payload(context, note, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let (encrypted_log, note_hash_counter) =\n            compute_payload(*context, e.note, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\npub fn encode_and_encrypt_note_unconstrained<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        //   Unconstrained logs have both their content and encryption unconstrained - it could occur that the\n        // recipient is unable to decrypt the payload.\n        //   Regarding the note hash counter, this is used for squashing. The kernel assumes that a given note can have\n        // more than one log and removes all of the matching ones, so all a malicious sender could do is either: cause\n        // for the log to be deleted when it shouldn't have (which is fine - they can already make the content be\n        // whatever), or cause for the log to not be deleted when it should have (which is also fine - it'll be a log\n        // for a note that doesn't exist).\n        //   It's important here that we do not\n        // return the log from this function to the app, otherwise it could try to do stuff with it and then that might\n        // be wrong.\n        let (encrypted_log, note_hash_counter) =\n            unsafe { compute_payload_unconstrained(*context, e.note, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n"
+    },
+    "105": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr",
+      "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::note::{\n    note_emission::NoteEmission,\n    note_header::NoteHeader,\n    note_interface::{NoteInterface, NullifiableNote},\n    utils::{compute_note_hash_for_nullify_internal, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n) -> NoteEmission<Note>\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    let note_hash_counter = context.side_effect_counter;\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    let serialized_note = Note::serialize_content(*note);\n    notify_created_note(\n        storage_slot,\n        Note::get_note_type_id(),\n        serialized_note,\n        note_hash,\n        note_hash_counter,\n    );\n\n    context.push_note_hash(note_hash);\n\n    NoteEmission::new(*note)\n}\n\npub fn create_note_hash_from_public<Note, let N: u32>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    // Public note hashes are transient, but have no side effect counters, so we just need note_hash_counter != 0\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter: 1 };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    context.push_note_hash(note_hash);\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note<Note, let N: u32>(context: &mut PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n\n    destroy_note_unsafe(context, note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe<Note, let N: u32>(\n    context: &mut PrivateContext,\n    note: Note,\n    note_hash_for_read_request: Field,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_nullify =\n        compute_note_hash_for_nullify_internal(note, note_hash_for_read_request);\n    let nullifier = note.compute_nullifier(context, note_hash_for_nullify);\n\n    let note_hash_counter = note.get_header().note_hash_counter;\n    let notification_note_hash = if (note_hash_counter == 0) {\n        // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n        0\n    } else {\n        // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n        // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n        // hash with real value to inform the kernel which note we're nullifyng so that it can either squash both\n        // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n        // a siloed note hash.\n        note_hash_for_nullify\n    };\n\n    let nullifier_counter = context.side_effect_counter;\n    notify_nullified_note(nullifier, notification_note_hash, nullifier_counter);\n\n    context.push_nullifier_for_note_hash(nullifier, notification_note_hash)\n}\n"
+    },
+    "108": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_getter/mod.nr",
+      "source": "use crate::context::PrivateContext;\nuse crate::note::{\n    constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n    note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::comparison::compare;\nuse dep::protocol_types::constants::{\n    GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector<let N: u32>(\n    serialized_note: [Field; N],\n    selector: PropertySelector,\n) -> Field {\n    // Selectors use PropertySelectors in order to locate note properties inside the serialized note.\n    // This allows easier packing and custom (de)serialization schemas. A note property is located\n    // inside the serialized note using the index inside the array, a byte offset and a length.\n    let value: [u8; 32] = serialized_note[selector.index].to_be_bytes();\n    let offset = selector.offset;\n    let length = selector.length;\n    let mut value_field = 0 as Field;\n    let mut acc: Field = 1;\n    for i in 0..32 {\n        if i < length {\n            value_field += value[31 + offset - i] as Field * acc;\n            acc = acc * 256;\n        }\n    }\n    value_field\n}\n\nfn check_note_header<Note, let N: u32>(context: PrivateContext, storage_slot: Field, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let header = note.get_header();\n    let contract_address = context.this_address();\n    assert(header.contract_address.eq(contract_address), \"Mismatch note header contract address.\");\n    assert(header.storage_slot == storage_slot, \"Mismatch note header storage slot.\");\n}\n\nfn check_note_fields<let N: u32>(\n    serialized_note: [Field; N],\n    selects: BoundedVec<Option<Select>, N>,\n) {\n    for i in 0..selects.len() {\n        let select = selects.get_unchecked(i).unwrap_unchecked();\n        let value_field =\n            extract_property_value_from_selector(serialized_note, select.property_selector);\n\n        assert(\n            compare(value_field, select.comparator, select.value.to_field()),\n            \"Mismatch return note field.\",\n        );\n    }\n}\n\nfn check_notes_order<let N: u32>(\n    fields_0: [Field; N],\n    fields_1: [Field; N],\n    sorts: BoundedVec<Option<Sort>, N>,\n) {\n    for i in 0..sorts.len() {\n        let sort = sorts.get_unchecked(i).unwrap_unchecked();\n        let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n        let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n        let eq = field_0 == field_1;\n        let lt = field_0.lt(field_1);\n        if sort.order == SortOrder.ASC {\n            assert(eq | lt, \"Return notes not sorted in ascending order.\");\n        } else if !eq {\n            assert(!lt, \"Return notes not sorted in descending order.\");\n        }\n    }\n}\n\npub fn get_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n) -> (Note, Field)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note = unsafe { get_note_internal(storage_slot) };\n\n    // Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do is check that\n    // the metadata is correct, and that the note exists.\n    check_note_header(*context, storage_slot, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    context.push_note_hash_read_request(note_hash_for_read_request);\n\n    (note, note_hash_for_read_request)\n}\n\npub fn get_notes<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n    // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n    // these checks correctly reject bad notes.\n    constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor<Note, PREPROCESSOR_ARGS>(\n    notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor: fn([Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n    preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    opt_notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n    // while the filter function can technically mutate the contents of the notes (as opposed to simply removing some),\n    // the private kernel will later validate that these note actually exist, so transformations would cause for that\n    // check to fail.\n    let filter_fn = options.filter;\n    let filter_args = options.filter_args;\n    let filtered_notes = filter_fn(opt_notes, filter_args);\n\n    let notes = crate::utils::array::collapse(filtered_notes);\n    let mut note_hashes: BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> =\n        BoundedVec::new();\n\n    // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n    // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n    // for the runtime length, and can therefore have fewer loop iterations.\n    assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n    let mut prev_fields = [0; N];\n    for i in 0..options.limit {\n        if i < notes.len() {\n            let note = notes.get_unchecked(i);\n            let fields = note.serialize_content();\n            check_note_header(*context, storage_slot, note);\n            check_note_fields(fields, options.selects);\n            if i != 0 {\n                check_notes_order(prev_fields, fields, options.sorts);\n            }\n            prev_fields = fields;\n\n            let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n            // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n            context.push_note_hash_read_request(note_hash_for_read_request);\n            note_hashes.push(note_hash_for_read_request);\n        };\n    }\n\n    (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal<Note, let N: u32>(storage_slot: Field) -> Note\nwhere\n    Note: NoteInterface<N>,\n{\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n    oracle::notes::get_notes(\n        storage_slot,\n        0,\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        NoteStatus.ACTIVE,\n        placeholder_note,\n        placeholder_fields,\n        placeholder_note_length,\n    )[0]\n        .expect(f\"Failed to get a note\") // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n    Note: NoteInterface<N>,\n{\n    // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let opt_notes = oracle::notes::get_notes(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\npub unconstrained fn view_notes<Note, let N: u32>(\n    storage_slot: Field,\n    options: NoteViewerOptions<Note, N>,\n) -> BoundedVec<Note, MAX_NOTES_PER_PAGE>\nwhere\n    Note: NoteInterface<N>,\n{\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let notes_array = oracle::notes::get_notes(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    let mut notes = BoundedVec::new();\n    for i in 0..notes_array.len() {\n        if notes_array[i].is_some() {\n            notes.push(notes_array[i].unwrap_unchecked());\n        }\n    }\n\n    notes\n}\n\nunconstrained fn flatten_options<let N: u32>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n    let mut num_selects = 0;\n    let mut select_by_indexes = [0; N];\n    let mut select_by_offsets = [0; N];\n    let mut select_by_lengths = [0; N];\n    let mut select_values = [0; N];\n    let mut select_comparators = [0; N];\n\n    for i in 0..selects.len() {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n            select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n            select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n            num_selects += 1;\n        };\n    }\n\n    let mut sort_by_indexes = [0; N];\n    let mut sort_by_offsets = [0; N];\n    let mut sort_by_lengths = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len() {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n            sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n            sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    }\n\n    (\n        num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n        select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n    )\n}\n"
+    },
+    "112": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_emission.nr",
+      "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission<Note> {\n    pub note: Note,\n}\n\nimpl<Note> NoteEmission<Note> {\n    pub fn new(note: Note) -> Self {\n        Self { note }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](Self) -> ()) {\n        _emit(self);\n    }\n\n    pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option<T>`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission<Note> {\n    emission: Option<NoteEmission<Note>>,\n}\n\nimpl<Note> OuterNoteEmission<Note> {\n    pub fn new(emission: Option<NoteEmission<Note>>) -> Self {\n        Self { emission }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](NoteEmission<Note>) -> ()) {\n        if self.emission.is_some() {\n            _emit(self.emission.unwrap());\n        }\n    }\n\n    pub fn discard(_self: Self) {}\n}\n"
+    },
+    "115": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/utils.nr",
+      "source": "use crate::{\n    context::PrivateContext,\n    note::{note_header::NoteHeader, note_interface::{NoteInterface, NullifiableNote}},\n    utils::array,\n};\n\nuse dep::protocol_types::hash::{\n    compute_siloed_note_hash, compute_siloed_nullifier as compute_siloed_nullifier_from_preimage,\n    compute_unique_note_hash,\n};\n\npub fn compute_siloed_nullifier<Note, let N: u32>(\n    note_with_header: Note,\n    context: &mut PrivateContext,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note_with_header.get_header();\n    let note_hash_for_nullify = compute_note_hash_for_nullify(note_with_header);\n    let inner_nullifier = note_with_header.compute_nullifier(context, note_hash_for_nullify);\n\n    compute_siloed_nullifier_from_preimage(header.contract_address, inner_nullifier)\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_read_request<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash = note.compute_note_hash();\n    let header = note.get_header();\n    let nonce = header.nonce;\n    let counter = header.note_hash_counter;\n\n    // If same tx note, read request always uses the normal note hash\n    if counter != 0 {\n        note_hash\n    } else {\n        // If the note comes from a different tx, we need to compute the note hash that reached the tree\n        compute_unique_note_hash(\n            nonce,\n            compute_siloed_note_hash(header.contract_address, note_hash),\n        )\n    }\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_nullify_internal<Note, let N: u32>(\n    note: Note,\n    note_hash_for_read_request: Field,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note.get_header();\n\n    if (header.note_hash_counter != 0) & (header.nonce != 0) {\n        // Non-revertible note, nullified by a revertible nullifier, we need to nullify the note hash that will reach the tree\n        let siloed_note_hash =\n            compute_siloed_note_hash(header.contract_address, note_hash_for_read_request);\n\n        compute_unique_note_hash(header.nonce, siloed_note_hash)\n    } else {\n        note_hash_for_read_request\n    }\n}\n\n// TODO(#7775): nuke this commented out code - kept it around as it contains comments which might be helpful when tackling #7775\n// pub fn compute_note_hash_for_nullify<Note, let N: u32, let M: u32>(note: Note) -> Field where Note: NoteInterface<N> {\n//     let header = note.get_header();\n//     // There are 3 cases for reading a note intended for consumption:\n//     // 1. The note was inserted in this transaction, is revertible, or is not nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce == 0)\n//     // 2. The note was inserted in this transaction, is non-revertible, and is nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce != 0)\n//     // 3. The note was inserted in a previous transaction: (note_hash_counter == 0) & (nonce != 0)\n\n//     let note_hash = note.compute_note_hiding_point().x;\n\n//     if header.nonce == 0 {\n//         // Case 1.\n//         // If a note is transient, we just read the note_hash (kernel will hash it with nonce and silo by contract address).\n//         note_hash\n//     } else {\n//         // Case 2: If a note is non-revertible, and is nullified by a revertible nullifier, we cannot squash them in the\n//         // private reset circuit. Because if the tx reverts, we will have to keep the note hash and throw away the\n//         // nullifier.\n//         // And if the tx does not revert, both will be emitted. In which case, the nullifier must be created in the app\n//         // from the siloed note hash.\n//         // The kernel circuit will check that a nullifier with non-zero note_nonce is linked to a note hash, whose\n//         // siloed note hash matches the note hash specified in the nullifier.\n\n//         // Case 3: If a note is not from the current transaction, that means we are reading a settled note (from\n//         // tree) created in a previous TX. So we need the siloed_note_hash which has already been hashed with\n//         // nonce and then contract address. This hash will match the existing leaf in the note hash\n//         // tree, so the kernel can just perform a membership check directly on this hash/leaf.\n//         let unique_note_hash = compute_unique_note_hash(header.nonce, note_hash);\n//         compute_siloed_note_hash(header.contract_address, unique_note_hash)\n//         // IMPORTANT NOTE ON REDUNDANT SILOING BY CONTRACT ADDRESS: The note hash computed above is\n//         // \"siloed\" by contract address. When a note hash is computed solely for the purpose of\n//         // nullification, it is not strictly necessary to silo the note hash before computing\n//         // its nullifier. In other words, it is NOT NECESSARY for protocol security that a nullifier\n//         // be computed from a siloed note hash. After all, persistable note hashes and nullifiers are\n//         // siloed by the kernel circuit. That being said, the siloed note hash computed above CAN be\n//         // used for nullifier computation, and this achieves the (arguably unnecessary) property that\n//         // nullifiers are computed from a note hash's fully-computed note hash tree leaf.\n//     }\n// }\n\npub fn compute_note_hash_for_nullify<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    compute_note_hash_for_nullify_internal(note, note_hash_for_read_request)\n}\n\npub unconstrained fn compute_note_hash_and_optionally_a_nullifier<T, let N: u32, let S: u32>(\n    deserialize_content: fn([Field; N]) -> T,\n    note_header: NoteHeader,\n    compute_nullifier: bool,\n    serialized_note: [Field; S],\n) -> [Field; 4]\nwhere\n    T: NoteInterface<N> + NullifiableNote,\n{\n    let mut note = deserialize_content(array::subarray(serialized_note, 0));\n    note.set_header(note_header);\n\n    let note_hash = note.compute_note_hash();\n    let siloed_note_hash = compute_siloed_note_hash(note_header.contract_address, note_hash);\n    let unique_note_hash = compute_unique_note_hash(note_header.nonce, siloed_note_hash);\n\n    let inner_nullifier = if compute_nullifier {\n        note.compute_nullifier_without_context()\n    } else {\n        0\n    };\n    // docs:start:compute_note_hash_and_optionally_a_nullifier_returns\n    [note_hash, unique_note_hash, siloed_note_hash, inner_nullifier]\n    // docs:end:compute_note_hash_and_optionally_a_nullifier_returns\n}\n"
+    },
+    "134": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/initializer.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress,\n    constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext},\n    oracle::get_contract_instance::{\n        get_contract_instance, get_contract_instance_deployer_avm,\n        get_contract_instance_initialization_hash_avm,\n    },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n    address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n    let address = context.this_address();\n    let deployer = get_contract_instance_deployer_avm(address).unwrap();\n    let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (deployer.is_zero()) | (deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n    let address = context.this_address();\n    let instance = get_contract_instance(address);\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn compute_initialization_hash(\n    init_selector: FunctionSelector,\n    init_args_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [init_selector.to_field(), init_args_hash],\n        GENERATOR_INDEX__CONSTRUCTOR,\n    )\n}\n"
     },
-    "79": {
+    "137": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
+      "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
+    },
+    "139": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/random.nr",
       "source": "/// Returns an unconstrained random value. Note that it is not possible to constrain this value to prove that it is\n/// truly random: we assume that the oracle is cooperating and returning random values.\n/// In some applications this behavior might not be acceptable and other techniques might be more suitable, such as\n/// producing pseudo-random values by hashing values outside of user control (like block hashes) or secrets.\npub unconstrained fn random() -> Field {\n    rand_oracle()\n}\n\n#[oracle(getRandomField)]\nunconstrained fn rand_oracle() -> Field {}\n"
     },
-    "83": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_nullifier_membership_witness.nr",
-      "source": "use crate::utils::array;\nuse dep::protocol_types::{\n    abis::nullifier_leaf_preimage::NullifierLeafPreimage, constants::NULLIFIER_TREE_HEIGHT,\n};\n\n// INDEX_LENGTH + NULLIFIER_LEAF_PREIMAGE_LENGTH + NULLIFIER_TREE_HEIGHT\nglobal NULLIFIER_MEMBERSHIP_WITNESS: u32 = 44;\n\npub struct NullifierMembershipWitness {\n    pub index: Field,\n    pub leaf_preimage: NullifierLeafPreimage,\n    pub path: [Field; NULLIFIER_TREE_HEIGHT],\n}\n\nimpl NullifierMembershipWitness {\n    pub fn deserialize(fields: [Field; NULLIFIER_MEMBERSHIP_WITNESS]) -> Self {\n        let serialized_leaf_preimage = array::subarray(fields, 1);\n\n        Self {\n            index: fields[0],\n            leaf_preimage: NullifierLeafPreimage::deserialize(serialized_leaf_preimage),\n            path: array::subarray(fields, 1 + serialized_leaf_preimage.len()),\n        }\n    }\n}\n\n#[oracle(getLowNullifierMembershipWitness)]\nunconstrained fn get_low_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_low_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_low_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n\n#[oracle(getNullifierMembershipWitness)]\nunconstrained fn get_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n"
+    "140": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/keys.nr",
+      "source": "use dep::protocol_types::{\n    address::{AztecAddress, PartialAddress},\n    point::Point,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n};\n\n#[oracle(getPublicKeysAndPartialAddress)]\nunconstrained fn get_public_keys_and_partial_address_oracle(_address: AztecAddress) -> [Field; 13] {}\n\npub unconstrained fn get_public_keys_and_partial_address(\n    address: AztecAddress,\n) -> (PublicKeys, PartialAddress) {\n    let result = get_public_keys_and_partial_address_oracle(address);\n\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: result[0], y: result[1], is_infinite: result[2] as bool } },\n        ivpk_m: IvpkM {\n            inner: Point { x: result[3], y: result[4], is_infinite: result[5] as bool },\n        },\n        ovpk_m: OvpkM {\n            inner: Point { x: result[6], y: result[7], is_infinite: result[8] as bool },\n        },\n        tpk_m: TpkM {\n            inner: Point { x: result[9], y: result[10], is_infinite: result[11] as bool },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(result[12]);\n\n    (keys, partial_address)\n}\n"
     },
-    "85": {
+    "142": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/key_validation_request.nr",
       "source": "use dep::protocol_types::abis::validation_requests::{\n    key_validation_request::KEY_VALIDATION_REQUEST_LENGTH, KeyValidationRequest,\n};\n\n#[oracle(getKeyValidationRequest)]\nunconstrained fn get_key_validation_request_oracle(\n    _pk_m_hash: Field,\n    _key_index: Field,\n) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {}\n\nunconstrained fn get_key_validation_request_internal(\n    npk_m_hash: Field,\n    key_index: Field,\n) -> KeyValidationRequest {\n    let result = get_key_validation_request_oracle(npk_m_hash, key_index);\n    KeyValidationRequest::deserialize(result)\n}\n\npub unconstrained fn get_key_validation_request(\n    pk_m_hash: Field,\n    key_index: Field,\n) -> KeyValidationRequest {\n    get_key_validation_request_internal(pk_m_hash, key_index)\n}\n"
     },
-    "86": {
+    "143": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/execution.nr",
       "source": "use dep::protocol_types::address::AztecAddress;\n\n#[oracle(getContractAddress)]\nunconstrained fn get_contract_address_oracle() -> AztecAddress {}\n\n#[oracle(getBlockNumber)]\nunconstrained fn get_block_number_oracle() -> u32 {}\n\n#[oracle(getChainId)]\nunconstrained fn get_chain_id_oracle() -> Field {}\n\n#[oracle(getVersion)]\nunconstrained fn get_version_oracle() -> Field {}\n\npub unconstrained fn get_contract_address() -> AztecAddress {\n    get_contract_address_oracle()\n}\n\npub unconstrained fn get_block_number() -> u32 {\n    get_block_number_oracle()\n}\n\npub unconstrained fn get_chain_id() -> Field {\n    get_chain_id_oracle()\n}\n\npub unconstrained fn get_version() -> Field {\n    get_version_oracle()\n}\n"
     },
-    "87": {
-      "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"
-    },
-    "88": {
+    "145": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/returns.nr",
       "source": "/// Notifies the simulator that `returns` will be later fetched once the function return is processed, referenced by\n/// their hash. This allows the simulator to know how to respond to this future request.\n///\n/// This is only used during private execution, since in public it is the VM itself that keeps track of return values.\npub fn pack_returns(returns: [Field]) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call. When\n    // unpacking however the caller must check that the returned value is indeed the preimage.\n    unsafe { pack_returns_oracle_wrapper(returns) };\n}\n\npub unconstrained fn pack_returns_oracle_wrapper(returns: [Field]) {\n    let _ = pack_returns_oracle(returns);\n}\n\npub unconstrained fn unpack_returns<let N: u32>(return_hash: Field) -> [Field; N] {\n    unpack_returns_oracle(return_hash)\n}\n\n#[oracle(packReturns)]\nunconstrained fn pack_returns_oracle(_returns: [Field]) -> Field {}\n\n#[oracle(unpackReturns)]\nunconstrained fn unpack_returns_oracle<let N: u32>(_return_hash: Field) -> [Field; N] {}\n"
     },
-    "91": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_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"
-    },
-    "92": {
-      "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"
+    "146": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_nullifier_membership_witness.nr",
+      "source": "use crate::utils::array;\nuse dep::protocol_types::{\n    abis::nullifier_leaf_preimage::NullifierLeafPreimage, constants::NULLIFIER_TREE_HEIGHT,\n};\n\n// INDEX_LENGTH + NULLIFIER_LEAF_PREIMAGE_LENGTH + NULLIFIER_TREE_HEIGHT\nglobal NULLIFIER_MEMBERSHIP_WITNESS: u32 = 44;\n\npub struct NullifierMembershipWitness {\n    pub index: Field,\n    pub leaf_preimage: NullifierLeafPreimage,\n    pub path: [Field; NULLIFIER_TREE_HEIGHT],\n}\n\nimpl NullifierMembershipWitness {\n    pub fn deserialize(fields: [Field; NULLIFIER_MEMBERSHIP_WITNESS]) -> Self {\n        let serialized_leaf_preimage = array::subarray(fields, 1);\n\n        Self {\n            index: fields[0],\n            leaf_preimage: NullifierLeafPreimage::deserialize(serialized_leaf_preimage),\n            path: array::subarray(fields, 1 + serialized_leaf_preimage.len()),\n        }\n    }\n}\n\n#[oracle(getLowNullifierMembershipWitness)]\nunconstrained fn get_low_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_low_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_low_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n\n#[oracle(getNullifierMembershipWitness)]\nunconstrained fn get_nullifier_membership_witness_oracle(\n    _block_number: u32,\n    _nullifier: Field,\n) -> [Field; NULLIFIER_MEMBERSHIP_WITNESS] {}\n\n// Nullifier here refers to the nullifier we are looking to get non-inclusion proof for (by proving that a lower\n// nullifier's next_value is bigger than the nullifier)\npub unconstrained fn get_nullifier_membership_witness(\n    block_number: u32,\n    nullifier: Field,\n) -> NullifierMembershipWitness {\n    let fields = get_nullifier_membership_witness_oracle(block_number, nullifier);\n    NullifierMembershipWitness::deserialize(fields)\n}\n"
     },
-    "93": {
+    "148": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/get_contract_instance.nr",
       "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::CONTRACT_INSTANCE_LENGTH, contract_class_id::ContractClassId,\n    contract_instance::ContractInstance,\n};\n\n// NOTE: this is for use in private only\n#[oracle(getContractInstance)]\nunconstrained fn get_contract_instance_oracle(\n    _address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {}\n\n// NOTE: this is for use in private only\nunconstrained fn get_contract_instance_internal(\n    address: AztecAddress,\n) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n    get_contract_instance_oracle(address)\n}\n\n// NOTE: this is for use in private only\npub fn get_contract_instance(address: AztecAddress) -> ContractInstance {\n    let instance =\n        unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\n    // The to_address function combines all values in the instance object to produce an address, so by checking that we\n    // get the expected address we validate the entire struct.\n    assert_eq(instance.to_address(), address);\n\n    instance\n}\n\n// These oracles each return a ContractInstance member\n// plus a boolean indicating whether the instance was found.\n#[oracle(avmOpcodeGetContractInstanceDeployer)]\nunconstrained fn get_contract_instance_deployer_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceClassId)]\nunconstrained fn get_contract_instance_class_id_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n#[oracle(avmOpcodeGetContractInstanceInitializationHash)]\nunconstrained fn get_contract_instance_initialization_hash_oracle_avm(\n    _address: AztecAddress,\n) -> (Field, bool) {}\n\npub unconstrained fn get_contract_instance_deployer_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_deployer_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_class_id_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_class_id_oracle_avm(address)\n}\npub unconstrained fn get_contract_instance_initialization_hash_internal_avm(\n    address: AztecAddress,\n) -> (Field, bool) {\n    get_contract_instance_initialization_hash_oracle_avm(address)\n}\n\npub fn get_contract_instance_deployer_avm(address: AztecAddress) -> Option<AztecAddress> {\n    let (member, exists) = get_contract_instance_deployer_internal_avm(address);\n    if exists {\n        Option::some(AztecAddress::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_class_id_avm(address: AztecAddress) -> Option<ContractClassId> {\n    let (member, exists) = get_contract_instance_class_id_internal_avm(address);\n    if exists {\n        Option::some(ContractClassId::from_field(member))\n    } else {\n        Option::none()\n    }\n}\npub fn get_contract_instance_initialization_hash_avm(address: AztecAddress) -> Option<Field> {\n    let (member, exists) = get_contract_instance_initialization_hash_internal_avm(address);\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
     },
-    "106": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    point::Point,\n    public_keys::{IvpkM, ToPoint},\n    scalar::Scalar,\n};\n\nuse crate::keys::secret_derivation::derive_aes_secret;\n\nuse std::aes128::aes128_encrypt;\n\npub struct EncryptedLogHeader {\n    address: AztecAddress,\n}\n\nimpl EncryptedLogHeader {\n    pub fn new(address: AztecAddress) -> Self {\n        EncryptedLogHeader { address }\n    }\n\n    pub fn compute_ciphertext<T>(self, secret: Scalar, pk: T) -> [u8; 48]\n    where\n        T: ToPoint,\n    {\n        let full_key = derive_aes_secret(secret, pk.to_point());\n        let mut sym_key = [0; 16];\n        let mut iv = [0; 16];\n\n        for i in 0..16 {\n            sym_key[i] = full_key[i];\n            iv[i] = full_key[i + 16];\n        }\n\n        let input: [u8; 32] = self.address.to_field().to_be_bytes();\n        aes128_encrypt(input, iv, sym_key).as_array()\n    }\n}\n\n#[test]\nunconstrained fn test_encrypted_log_header_matches_noir() {\n    let address = AztecAddress::from_field(0xdeadbeef);\n    let header = EncryptedLogHeader::new(address);\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = IvpkM {\n        inner: Point {\n            x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n            y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n            is_infinite: false,\n        },\n    };\n\n    let ciphertext = header.compute_ciphertext(secret, point);\n\n    // The following value was generated by `encrypted_log_header.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_header_ciphertext_from_typescript = [\n        226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 194, 44, 7, 131,\n        160, 83, 64, 181, 98, 38, 153, 214, 62, 171, 253, 161, 111, 191, 28, 247, 216, 26, 222, 171,\n        176, 218, 48, 209, 73, 89, 200, 209,\n    ];\n\n    assert_eq(ciphertext, expected_header_ciphertext_from_typescript);\n}\n"
-    },
-    "107": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/encrypted_note_emission.nr",
-      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::payload::compute_private_log_payload,\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n};\n\n/// Computes private note log payload\nfn compute_payload<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\n    let storage_slot = note_header.storage_slot;\n\n    // TODO(#8589): use typesystem to skip this check when not needed\n    let note_exists =\n        context.note_hashes.storage().any(|n: NoteHash| n.counter == note_hash_counter);\n    assert(note_exists, \"Can only emit a note log for an existing note.\");\n\n    let contract_address: AztecAddress = context.this_address();\n\n    let plaintext = note.to_be_bytes(storage_slot);\n\n    let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n    (payload, note_hash_counter)\n}\n\nunconstrained fn compute_payload_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> ([Field; PRIVATE_LOG_SIZE_IN_FIELDS], u32)\nwhere\n    Note: NoteInterface<N>,\n{\n    compute_payload(context, note, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let (encrypted_log, note_hash_counter) =\n            compute_payload(*context, e.note, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\npub fn encode_and_encrypt_note_unconstrained<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        //   Unconstrained logs have both their content and encryption unconstrained - it could occur that the\n        // recipient is unable to decrypt the payload.\n        //   Regarding the note hash counter, this is used for squashing. The kernel assumes that a given note can have\n        // more than one log and removes all of the matching ones, so all a malicious sender could do is either: cause\n        // for the log to be deleted when it shouldn't have (which is fine - they can already make the content be\n        // whatever), or cause for the log to not be deleted when it should have (which is also fine - it'll be a log\n        // for a note that doesn't exist).\n        //   It's important here that we do not\n        // return the log from this function to the app, otherwise it could try to do stuff with it and then that might\n        // be wrong.\n        let (encrypted_log, note_hash_counter) =\n            unsafe { compute_payload_unconstrained(*context, e.note, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n"
-    },
-    "108": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/encrypted_logs/payload.nr",
-      "source": "use dep::protocol_types::{\n    address::AztecAddress,\n    constants::{GENERATOR_INDEX__SYMMETRIC_KEY, PRIVATE_LOG_SIZE_IN_FIELDS},\n    hash::poseidon2_hash,\n    point::Point,\n    public_keys::AddressPoint,\n    scalar::Scalar,\n    utils::arrays::array_concat,\n};\nuse std::{\n    aes128::aes128_encrypt, embedded_curve_ops::fixed_base_scalar_mul as derive_public_key,\n    field::bn254::decompose, hash::from_field_unsafe as fr_to_fq_unsafe,\n};\n\nuse crate::{\n    encrypted_logs::header::EncryptedLogHeader,\n    keys::secret_derivation::derive_aes_secret,\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::bytes_to_fields, point::point_to_bytes},\n};\n\n// 1 field is reserved for tag.\nglobal ENCRYPTED_PAYLOAD_SIZE_IN_BYTES: u32 = (PRIVATE_LOG_SIZE_IN_FIELDS - 1) * 31;\n\ncomptime global HEADER_SIZE: u32 = 48;\n\n// Bytes padded to the overhead, so that the size of the incoming body ciphertext will be a multiple of 16.\ncomptime global OVERHEAD_PADDING: u32 = 15;\n\npub comptime global OVERHEAD_SIZE: u32 = 32 /* eph_pk */\n    + HEADER_SIZE /* incoming_header */\n    + OVERHEAD_PADDING /* padding */;\n\nglobal PLAINTEXT_LENGTH_SIZE: u32 = 2;\n\n// This is enough for 8 fields of data.\n// 1 field for storage slot, 1 field for note/event type id, allowing 6 fields for custom values.\nglobal MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES: u32 =\n    ENCRYPTED_PAYLOAD_SIZE_IN_BYTES - OVERHEAD_SIZE - PLAINTEXT_LENGTH_SIZE - 1 /* aes padding */;\n\n// Note: Might have to update PRIVATE_LOG_SIZE_IN_FIELDS in `constants.nr` if the above changes.\n// This value ideally should be set by the protocol, allowing users (or `aztec-nr`) to fit data within the defined size limits.\n// Currently, we adjust this value as the structure changes, then update `constants.nr` to match.\n// Once the structure is finalized with defined overhead and max note field sizes, this value will be fixed and should remain unaffected by further payload composition changes.\n\npub fn compute_private_log_payload<let P: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS] {\n    assert(\n        P < MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n        f\"plaintext for log must not exceed {MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES}\",\n    );\n\n    let extended_plaintext: [u8; MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; ENCRYPTED_PAYLOAD_SIZE_IN_BYTES] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n\n    array_concat([tag], bytes_to_fields(encrypted))\n}\n\npub fn compute_partial_public_log_payload<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let extended_plaintext: [u8; P + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; M - 32] =\n        compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    // We assume that the sender wants for the recipient to find the tagged note, and therefore that they will cooperate\n    // and use the correct tag. Usage of a bad tag will result in the recipient not being able to find the note\n    // automatically.\n    let tag = unsafe { get_app_tag_as_sender(sender, recipient) };\n    increment_app_tagging_secret_index_as_sender(sender, recipient);\n    // Silo the tag with contract address.\n    // This is done by the kernel circuit to the private logs, but since the partial log will be finalized and emitted\n    // in public as unencrypted log, its tag is not siloed at the moment.\n    // To avoid querying logs using two types of tags, we silo the tag manually here.\n    // TODO(#10273) This should be done by the AVM when it's processing the raw logs instead of their hashes.\n    let siloed_tag_bytes: [u8; 32] =\n        poseidon2_hash([contract_address.to_field(), tag]).to_be_bytes();\n\n    // Temporary hack so that the partial public log remains the same format.\n    // It should return field array and make the tag the first field as compute_private_log_payload does.\n    let mut log_bytes = [0; M];\n    for i in 0..32 {\n        log_bytes[i] = siloed_tag_bytes[i];\n    }\n    for i in 0..encrypted.len() {\n        log_bytes[i + 32] = encrypted[i];\n    }\n\n    log_bytes\n}\n\nfn compute_encrypted_log<let P: u32, let M: u32>(\n    contract_address: AztecAddress,\n    recipient: AztecAddress,\n    plaintext: [u8; P],\n) -> [u8; M] {\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let header = EncryptedLogHeader::new(contract_address);\n\n    let incoming_header_ciphertext: [u8; 48] =\n        header.compute_ciphertext(eph_sk, recipient.to_address_point());\n    let incoming_body_ciphertext =\n        compute_incoming_body_ciphertext(plaintext, eph_sk, recipient.to_address_point());\n\n    let mut encrypted_bytes = [0; M];\n    let mut offset = 0;\n\n    // eph_pk\n    let eph_pk_bytes = point_to_bytes(eph_pk);\n    for i in 0..32 {\n        encrypted_bytes[offset + i] = eph_pk_bytes[i];\n    }\n    offset += 32;\n\n    // incoming_header\n    for i in 0..HEADER_SIZE {\n        encrypted_bytes[offset + i] = incoming_header_ciphertext[i];\n    }\n    offset += HEADER_SIZE;\n\n    // Padding.\n    offset += OVERHEAD_PADDING;\n\n    // incoming_body\n    // Then we fill in the rest as the incoming body ciphertext\n    let size = M - offset;\n    assert_eq(size, incoming_body_ciphertext.len(), \"ciphertext length mismatch\");\n    for i in 0..size {\n        encrypted_bytes[offset + i] = incoming_body_ciphertext[i];\n    }\n\n    encrypted_bytes\n}\n\n// Prepend the plaintext length as the first byte, then copy the plaintext itself starting from the second byte.\n// Fill the remaining bytes with random values to reach a fixed length of N.\nfn extend_private_log_plaintext<let P: u32, let N: u32>(plaintext: [u8; P]) -> [u8; N] {\n    let mut padded = unsafe { get_random_bytes() };\n    padded[0] = (P >> 8) as u8;\n    padded[1] = P as u8;\n    for i in 0..P {\n        padded[i + PLAINTEXT_LENGTH_SIZE] = plaintext[i];\n    }\n    padded\n}\n\nunconstrained fn get_random_bytes<let N: u32>() -> [u8; N] {\n    let mut bytes = [0; N];\n    let mut idx = 32;\n    let mut randomness = [0; 32];\n    for i in 0..N {\n        if idx == 32 {\n            randomness = random().to_be_bytes();\n            idx = 1; // Skip the first byte as it's always 0.\n        }\n        bytes[i] = randomness[idx];\n        idx += 1;\n    }\n    bytes\n}\n\n/// Converts a base field element to scalar field element.\n/// This is fine because modulus of the base field is smaller than the modulus of the scalar field.\nfn fr_to_fq(r: Field) -> Scalar {\n    let (lo, hi) = decompose(r);\n\n    Scalar { lo, hi }\n}\n\nfn generate_ephemeral_key_pair() -> (Scalar, Point) {\n    // @todo Need to draw randomness from the full domain of Fq not only Fr\n    // We use the randomness to preserve the privacy of both the sender and recipient via encryption, so a malicious\n    // sender could use non-random values to reveal the plaintext. But they already know it themselves anyway, and so\n    // the recipient already trusts them to not disclose this information. We can therefore assume that the sender will\n    // cooperate in the random value generation.\n    let randomness = unsafe { random() };\n\n    // We use the unsafe version of `fr_to_fq` because multi_scalar_mul (called by derive_public_key) will constrain\n    // the scalars.\n    let eph_sk = fr_to_fq_unsafe(randomness);\n    let eph_pk = derive_public_key(eph_sk);\n\n    (eph_sk, eph_pk)\n}\n\npub fn compute_incoming_body_ciphertext<let P: u32>(\n    plaintext: [u8; P],\n    eph_sk: Scalar,\n    address_point: AddressPoint,\n) -> [u8] {\n    let full_key = derive_aes_secret(eph_sk, address_point.to_point());\n    let mut sym_key = [0; 16];\n    let mut iv = [0; 16];\n\n    for i in 0..16 {\n        sym_key[i] = full_key[i];\n        iv[i] = full_key[i + 16];\n    }\n    aes128_encrypt(plaintext, iv, sym_key)\n}\n\nmod test {\n    use crate::encrypted_logs::payload::{\n        compute_incoming_body_ciphertext, compute_private_log_payload,\n        MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES,\n    };\n    use dep::protocol_types::{address::AztecAddress, point::Point, scalar::Scalar};\n    use protocol_types::public_keys::AddressPoint;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_log_payload.test.ts`\n        let contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        );\n\n        let plaintext = [\n            0, 0, 0, 1, 48, 22, 64, 206, 234, 117, 131, 145, 178, 225, 97, 201, 44, 5, 19, 241, 41,\n            2, 15, 65, 37, 37, 106, 253, 174, 38, 70, 206, 49, 9, 159, 92, 16, 244, 140, 217, 239,\n            247, 174, 91, 32, 156, 85, 124, 112, 222, 46, 101, 126, 231, 145, 102, 134, 134, 118,\n            183, 135, 233, 65, 126, 25, 38, 14, 4, 15, 228, 107, 229, 131, 183, 31, 74, 181, 183,\n            12, 38, 87, 255, 29, 5, 204, 207, 29, 41, 42, 147, 105, 98, 141, 26, 25, 79, 148, 78,\n            101, 153, 0, 0, 16, 39,\n        ];\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(\n            (MAX_PRIVATE_LOG_PLAINTEXT_SIZE_IN_BYTES as u64 + 1 + 30) / 31,\n        );\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let recipient = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let sender = AztecAddress::from_field(\n            0x25afb798ea6d0b8c1618e50fdeafa463059415013d3b7c75d46abf5e242be70c,\n        );\n\n        let _ = OracleMock::mock(\"getAppTaggingSecretAsSender\").returns([69420, 1337]);\n\n        let _ = OracleMock::mock(\"incrementAppTaggingSecretIndexAsSender\").returns(());\n\n        let payload = compute_private_log_payload(contract_address, recipient, sender, plaintext);\n\n        // The following value was generated by `encrypted_log_payload.test.ts`\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let private_log_payload_from_typescript = [\n            0x0e9cffc3ddd746affb02410d8f0a823e89939785bcc8e88ee4f3cae05e737c36,\n            0x008d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701f,\n            0x00a70577790aeabcc2d81ec8d0c99e7f5d2bf2f1452025dc777a178404f851d9,\n            0x003de818923f85187871d99bdf95d695eff0a900000000000000000000000000,\n            0x000000a600a61f7d59eeaf52eb51bc0592ff981d9ba3ea8e6ea8ba9dc0cec8c7,\n            0x000b81e84556a77ce6c3ca47a527f99ffe7b2524bb885a23020b7295748ad19c,\n            0x001083618ad96298b76ee07eb1a56d19cc798710e9f5de96501bd59b3781c9c0,\n            0x002a6c95c5912f8936b1500d362afbf0922c85b1ada18db8b95162a6e9d06765,\n            0x005cdf669eb387f8e0492a95fdcdb39429d5340b4bebc250ba9bf62c2f49f549,\n            0x00f37beed75a668aa51967e0e57547e5a655157bcf381e22f30e25881548ec96,\n            0x0006a151b5fbfb2d14ee4b34bf4c1dbd71c7be15ad4c63474bb6f89970aeb3d9,\n            0x00489c8edbdff80a1a3a5c28370e534abc870a85ea4318326ea19222fb10df35,\n            0x008c765edada497db4284ae30507a2e03e983d23cfa0bd831577e857bbef9cf7,\n            0x0090c97cb5699cc8783a1b4276d929be2882e5b9b72829a4f8404f7e3c853d11,\n            0x00d6d5a000b80134891e95f81007ad35d3945eaeecbe137fff85d01d7eaf8f19,\n            0x00a15eb965c6a4bc97aa87fd3463c31c9d4e0d722a8ba870bcc50c9c7a8b48ad,\n            0x0063c861bdbe490d44c57382decbae663927909652f87ac18dcfd5b30649cce5,\n            0x00820f14caa725efe1fa3485ceac88499eadf0565c5b20998c05931bbf478e68,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n\n    #[test]\n    fn test_incoming_body_ciphertext_matches_typescript() {\n        // All the values in this test were copied over from `encrypted_note_log_incoming_body.test.ts`\n        let eph_sk = Scalar {\n            lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n            hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n        };\n        let address_point = AddressPoint {\n            inner: Point {\n                x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n                y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n                is_infinite: false,\n            },\n        };\n        let plaintext = [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3,\n        ];\n\n        // `compute_incoming_body_ciphertext(...)` function then derives symmetric key from `eph_sk` and `address_point` and encrypts\n        // the note plaintext using AES-128.\n        let ciphertext = compute_incoming_body_ciphertext(plaintext, eph_sk, address_point);\n\n        // The following value was generated by `encrypted_note_log_incoming_body.test.ts`.\n        // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n        let note_body_ciphertext_from_typescript = [\n            226, 240, 253, 6, 28, 52, 19, 131, 33, 132, 178, 212, 245, 62, 14, 190, 147, 228, 160,\n            190, 146, 61, 95, 203, 124, 153, 68, 168, 17, 150, 92, 0, 99, 214, 85, 64, 191, 78, 157,\n            131, 149, 96, 236, 253, 96, 172, 157, 30, 27, 176, 228, 74, 242, 190, 138, 48, 33, 93,\n            46, 37, 223, 130, 25, 245, 188, 163, 159, 223, 187, 24, 139, 206, 131, 154, 159, 130,\n            37, 17, 158, 114, 242, 141, 124, 193, 232, 54, 146, 96, 145, 100, 125, 234, 57, 43, 95,\n            115, 183, 39, 121, 232, 134, 229, 148, 25, 46, 77, 87, 127, 95, 7, 77, 188, 37, 234,\n            245, 142, 232, 87, 252, 28, 67, 67, 90, 214, 254, 89, 47, 68, 66, 187, 227, 8, 59, 162,\n            25, 141, 97, 141, 217, 197, 115, 15, 212, 202, 157, 41, 150, 62, 219, 57, 224, 92, 185,\n            212, 142, 94, 146, 41, 178, 145, 68, 169, 23, 185, 206, 138, 70, 47, 176, 210, 165, 236,\n            23, 206, 229, 108,\n        ];\n\n        assert_eq(note_body_ciphertext_from_typescript.len(), ciphertext.len());\n\n        for i in 0..note_body_ciphertext_from_typescript.len() {\n            assert_eq(ciphertext[i], note_body_ciphertext_from_typescript[i]);\n        }\n    }\n}\n"
+    "150": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "111": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
-      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must be large enough to hold all of\n/// the elements past `offset`.\n///\n/// Example:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n/// ```\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
+    "151": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
+      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "114": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/utils/point.nr",
-      "source": "use dep::protocol_types::point::Point;\n\n// I am storing the modulus minus 1 divided by 2 here because full modulus would throw \"String literal too large\" error\n// Full modulus is 21888242871839275222246405745257275088548364400416034343698204186575808495617\nglobal BN254_FR_MODULUS_DIV_2: Field =\n    10944121435919637611123202872628637544274182200208017171849102093287904247808;\n\n/// Converts a public key to a byte array.\n///\n/// We don't serialize the point at infinity flag because this function is used in situations where we do not want\n/// to waste the extra byte (encrypted log).\npub fn point_to_bytes(pk: Point) -> [u8; 32] {\n    // Note that there is 1 more free bit in the 32 bytes (254 bits currently occupied by the x coordinate, 1 bit for\n    // the \"sign\") so it's possible to use that last bit as an \"is_infinite\" flag if desired in the future.\n    assert(!pk.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = pk.x.to_be_bytes();\n\n    // We store only a \"sign\" of the y coordinate because the rest can be derived from the x coordinate. To get\n    // the sign we check if the y coordinate is less or equal than the curve's order minus 1 divided by 2.\n    // Ideally we'd do `y <= MOD_DIV_2`, but there's no `lte` function, so instead we do `!(y > MOD_DIV_2)`, which is\n    // equivalent, and then rewrite that as `!(MOD_DIV_2 < y)`, since we also have no `gt` function.\n    if !BN254_FR_MODULUS_DIV_2.lt(pk.y) {\n        // y is <= (modulus - 1) / 2 so we set the sign bit to 1\n        // Here we leverage that field fits into 254 bits (log2(Fr.MODULUS) < 254) and given that we serialize Fr to 32\n        // bytes and we use big-endian the 2 most significant bits are never populated. Hence we can use one of\n        // the bits as a sign bit.\n        result[0] += 128;\n    }\n\n    result\n}\n\nmod test {\n    use crate::utils::point::point_to_bytes;\n    use dep::protocol_types::point::Point;\n\n    #[test]\n    unconstrained fn test_point_to_bytes_positive_sign() {\n        let p = Point {\n            x: 0x1af41f5de96446dc3776a1eb2d98bb956b7acd9979a67854bec6fa7c2973bd73,\n            y: 0x07fc22c7f2c7057571f137fe46ea9c95114282bc95d37d71ec4bfb88de457d4a,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_positive_sign = [\n            154, 244, 31, 93, 233, 100, 70, 220, 55, 118, 161, 235, 45, 152, 187, 149, 107, 122,\n            205, 153, 121, 166, 120, 84, 190, 198, 250, 124, 41, 115, 189, 115,\n        ];\n        assert_eq(expected_compressed_point_positive_sign, compressed_point);\n    }\n\n    #[test]\n    unconstrained fn test_point_to_bytes_negative_sign() {\n        let p = Point {\n            x: 0x247371652e55dd74c9af8dbe9fb44931ba29a9229994384bd7077796c14ee2b5,\n            y: 0x26441aec112e1ae4cee374f42556932001507ad46e255ffb27369c7e3766e5c0,\n            is_infinite: false,\n        };\n\n        let compressed_point = point_to_bytes(p);\n\n        let expected_compressed_point_negative_sign = [\n            36, 115, 113, 101, 46, 85, 221, 116, 201, 175, 141, 190, 159, 180, 73, 49, 186, 41, 169,\n            34, 153, 148, 56, 75, 215, 7, 119, 150, 193, 78, 226, 181,\n        ];\n\n        assert_eq(expected_compressed_point_negative_sign, compressed_point);\n    }\n}\n"
+    "156": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/hash.nr",
+      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
     },
-    "119": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/initializer.nr",
-      "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress,\n    constants::GENERATOR_INDEX__CONSTRUCTOR, hash::poseidon2_hash_with_separator,\n};\n\nuse crate::{\n    context::{PrivateContext, PublicContext},\n    oracle::get_contract_instance::{\n        get_contract_instance, get_contract_instance_deployer_avm,\n        get_contract_instance_initialization_hash_avm,\n    },\n};\n\npub fn mark_as_initialized_public(context: &mut PublicContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn mark_as_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier =\n        compute_unsiloed_contract_initialization_nullifier((*context).this_address());\n    context.push_nullifier(init_nullifier);\n}\n\npub fn assert_is_initialized_public(context: &mut PublicContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    assert(context.nullifier_exists(init_nullifier, context.this_address()), \"Not initialized\");\n}\n\npub fn assert_is_initialized_private(context: &mut PrivateContext) {\n    let init_nullifier = compute_unsiloed_contract_initialization_nullifier(context.this_address());\n    context.push_nullifier_read_request(init_nullifier);\n}\n\nfn compute_unsiloed_contract_initialization_nullifier(address: AztecAddress) -> Field {\n    address.to_field()\n}\n\npub fn assert_initialization_matches_address_preimage_public(context: PublicContext) {\n    let address = context.this_address();\n    let deployer = get_contract_instance_deployer_avm(address).unwrap();\n    let initialization_hash = get_contract_instance_initialization_hash_avm(address).unwrap();\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (deployer.is_zero()) | (deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn assert_initialization_matches_address_preimage_private(context: PrivateContext) {\n    let address = context.this_address();\n    let instance = get_contract_instance(address);\n    let expected_init = compute_initialization_hash(context.selector(), context.get_args_hash());\n    assert(instance.initialization_hash == expected_init, \"Initialization hash does not match\");\n    assert(\n        (instance.deployer.is_zero()) | (instance.deployer == context.msg_sender()),\n        \"Initializer address is not the contract deployer\",\n    );\n}\n\npub fn compute_initialization_hash(\n    init_selector: FunctionSelector,\n    init_args_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [init_selector.to_field(), init_args_hash],\n        GENERATOR_INDEX__CONSTRUCTOR,\n    )\n}\n"
+    "157": {
+      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/generators.nr",
+      "source": "use dep::protocol_types::point::Point;\n\n// A set of generators generated with `derive_generators(...)` function from noir::std\npub global Ga1: Point = Point {\n    x: 0x30426e64aee30e998c13c8ceecda3a77807dbead52bc2f3bf0eae851b4b710c1,\n    y: 0x113156a068f603023240c96b4da5474667db3b8711c521c748212a15bc034ea6,\n    is_infinite: false,\n};\npub global Ga2: Point = Point {\n    x: 0x2825c79cc6a5cbbeef7d6a8f1b6a12b312aa338440aefeb4396148c89147c049,\n    y: 0x129bfd1da54b7062d6b544e7e36b90736350f6fba01228c41c72099509f5701e,\n    is_infinite: false,\n};\npub global Ga3: Point = Point {\n    x: 0x0edb1e293c3ce91bfc04e3ceaa50d2c541fa9d091c72eb403efb1cfa2cb3357f,\n    y: 0x1341d675fa030ece3113ad53ca34fd13b19b6e9762046734f414824c4d6ade35,\n    is_infinite: false,\n};\npub global Ga4: Point = Point {\n    x: 0x0e0dad2250583f2a9f0acb04ededf1701b85b0393cae753fe7e14b88af81cb52,\n    y: 0x0973b02c5caac339ee4ad5dab51329920f7bf1b6a07e1dabe5df67040b300962,\n    is_infinite: false,\n};\npub global Ga5: Point = Point {\n    x: 0x2f3342e900e8c488a28931aae68970738fdc68afde2910de7b320c00c902087d,\n    y: 0x1bf958dc63cb09d59230603a0269ae86d6f92494da244910351f1132df20fc08,\n    is_infinite: false,\n};\n// If you change this update `G_SLOT` in `yarn-project/simulator/src/client/test_utils.ts` as well\npub global G_slot: Point = Point {\n    x: 0x041223147b680850dc82e8a55a952d4df20256fe0593d949a9541ca00f0abf15,\n    y: 0x0a8c72e60d0e60f5d804549d48f3044d06140b98ed717a9b532af630c1530791,\n    is_infinite: false,\n};\n\nmod test {\n    use crate::generators::{G_slot, Ga1, Ga2, Ga3, Ga4, Ga5};\n    use dep::protocol_types::point::Point;\n    use std::hash::derive_generators;\n\n    #[test]\n    unconstrained fn test_generators() {\n        let generators: [Point; 6] = derive_generators(\"aztec_nr_generators\".as_bytes(), 0);\n        assert_eq(generators[0], Ga1);\n        assert_eq(generators[1], Ga2);\n        assert_eq(generators[2], Ga3);\n        assert_eq(generators[4], Ga4);\n        assert_eq(generators[5], Ga5);\n        assert_eq(generators[3], G_slot);\n    }\n}\n"
     },
-    "129": {
+    "171": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/keys/getters/mod.nr",
       "source": "use crate::{\n    keys::constants::{NULLIFIER_INDEX, OUTGOING_INDEX},\n    oracle::{\n        key_validation_request::get_key_validation_request,\n        keys::get_public_keys_and_partial_address,\n    },\n};\nuse dep::protocol_types::{address::AztecAddress, public_keys::PublicKeys};\n\nmod test;\n\npub unconstrained fn get_nsk_app(npk_m_hash: Field) -> Field {\n    get_key_validation_request(npk_m_hash, NULLIFIER_INDEX).sk_app\n}\n\n// A helper function that gets app-siloed outgoing viewing key for a given `ovpk_m_hash`. This function is used\n// in unconstrained contexts only - when computing unconstrained note logs. The safe alternative is `request_ovsk_app`\n// function defined on `PrivateContext`.\npub unconstrained fn get_ovsk_app(ovpk_m_hash: Field) -> Field {\n    get_key_validation_request(ovpk_m_hash, OUTGOING_INDEX).sk_app\n}\n\n// Returns all public keys for a given account, applying proper constraints to the context. We read all\n// keys at once since the constraints for reading them all are actually fewer than if we read them one at a time - any\n// read keys that are not required by the caller can simply be discarded.\npub fn get_public_keys(account: AztecAddress) -> PublicKeys {\n    // Public keys are constrained by showing their inclusion in the address's preimage.\n    let (public_keys, partial_address) = unsafe { get_public_keys_and_partial_address(account) };\n    assert_eq(\n        account,\n        AztecAddress::compute(public_keys, partial_address),\n        \"Invalid public keys hint for address\",\n    );\n\n    public_keys\n}\n"
     },
-    "131": {
+    "173": {
       "path": "/usr/src/noir-projects/aztec-nr/aztec/src/keys/secret_derivation.nr",
       "source": "use crate::utils::point::point_to_bytes;\nuse dep::protocol_types::{constants::GENERATOR_INDEX__SYMMETRIC_KEY, point::Point, scalar::Scalar};\nuse std::{embedded_curve_ops::multi_scalar_mul, hash::sha256};\n\npub fn derive_aes_secret(secret: Scalar, point: Point) -> [u8; 32] {\n    let shared_secret = point_to_bytes(multi_scalar_mul([point], [secret]));\n\n    let mut shared_secret_bytes_with_separator: [u8; 33] = std::mem::zeroed();\n    for i in 0..shared_secret.len() {\n        shared_secret_bytes_with_separator[i] = shared_secret[i];\n    }\n\n    shared_secret_bytes_with_separator[32] = GENERATOR_INDEX__SYMMETRIC_KEY;\n\n    sha256(shared_secret_bytes_with_separator)\n}\n\n#[test]\nunconstrained fn test_derive_aes_secret_matches_noir() {\n    // Value taken from \"derive shared secret\" test in encrypt_buffer.test.ts\n    let secret = Scalar {\n        lo: 0x00000000000000000000000000000000649e7ca01d9de27b21624098b897babd,\n        hi: 0x0000000000000000000000000000000023b3127c127b1f29a7adff5cccf8fb06,\n    };\n    let point = Point {\n        x: 0x2688431c705a5ff3e6c6f2573c9e3ba1c1026d2251d0dbbf2d810aa53fd1d186,\n        y: 0x1e96887b117afca01c00468264f4f80b5bb16d94c1808a448595f115556e5c8e,\n        is_infinite: false,\n    };\n\n    let key = derive_aes_secret(secret, point);\n\n    // The following value was generated by `encrypt_buffer.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let key_from_typescript = [\n        251, 232, 177, 34, 2, 174, 35, 92, 165, 118, 168, 3, 153, 140, 46, 210, 203, 154, 184, 158,\n        236, 33, 95, 77, 93, 120, 72, 88, 190, 209, 64, 159,\n    ];\n    assert_eq(key, key_from_typescript);\n}\n"
     },
-    "152": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/state_vars/private_immutable.nr",
-      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize},\n};\n\nuse crate::context::{PrivateContext, UnconstrainedContext};\nuse crate::note::{\n    lifecycle::create_note,\n    note_emission::NoteEmission,\n    note_getter::{get_note, view_notes},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n};\nuse crate::oracle::notes::check_nullifier_exists;\nuse crate::state_vars::storage::Storage;\n\n// docs:start:struct\npub struct PrivateImmutable<Note, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n// docs:end:struct\n\nimpl<T, Context, let N: u32> Storage<T, N> for PrivateImmutable<T, Context>\nwhere\n    T: Serialize<N> + Deserialize<N>,\n{}\n\nimpl<Note, Context> PrivateImmutable<Note, Context> {\n    // docs:start:new\n    pub fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n    // docs:end:new\n\n    // The following computation is leaky, in that it doesn't hide the storage slot that has been initialized, nor does it hide the contract address of this contract.\n    // When this initialization nullifier is emitted, an observer could do a dictionary or rainbow attack to learn the preimage of this nullifier to deduce the storage slot and contract address.\n    // For some applications, leaking the details that a particular state variable of a particular contract has been initialized will be unacceptable.\n    // Under such circumstances, such application developers might wish to _not_ use this state variable type.\n    // This is especially dangerous for initial assignment to elements of a `Map<AztecAddress, PrivateImmutable>` type (for example), because the storage slot often also identifies an actor.\n    // e.g. the initial assignment to `my_map.at(msg.sender)` will leak: `msg.sender`, the fact that an element of `my_map` was assigned-to for the first time, and the contract_address.\n    pub fn compute_initialization_nullifier(self) -> Field {\n        poseidon2_hash_with_separator(\n            [self.storage_slot],\n            GENERATOR_INDEX__INITIALIZATION_NULLIFIER,\n        )\n    }\n}\n\nimpl<Note> PrivateImmutable<Note, &mut PrivateContext> {\n    // docs:start:initialize\n    pub fn initialize<let N: u32>(self, note: &mut Note) -> NoteEmission<Note>\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        // Nullify the storage slot.\n        let nullifier = self.compute_initialization_nullifier();\n        self.context.push_nullifier(nullifier);\n\n        create_note(self.context, self.storage_slot, note)\n    }\n    // docs:end:initialize\n\n    // docs:start:get_note\n    pub fn get_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let storage_slot = self.storage_slot;\n        get_note(self.context, storage_slot).0\n    }\n    // docs:end:get_note\n}\n\nimpl<Note> PrivateImmutable<Note, UnconstrainedContext> {\n    // docs:start:is_initialized\n    pub unconstrained fn is_initialized(self) -> bool {\n        let nullifier = self.compute_initialization_nullifier();\n        check_nullifier_exists(nullifier)\n    }\n    // docs:end:is_initialized\n\n    // view_note does not actually use the context, but it calls oracles that are only available in private\n    // docs:start:view_note\n    pub unconstrained fn view_note<let N: u32>(self) -> Note\n    where\n        Note: NoteInterface<N> + NullifiableNote,\n    {\n        let mut options = NoteViewerOptions::new();\n        view_notes(self.storage_slot, options.set_limit(1)).get(0)\n    }\n    // docs:end:view_note\n}\n"
+    "176": {
+      "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"
     },
-    "163": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/lifecycle.nr",
-      "source": "use crate::context::{PrivateContext, PublicContext};\nuse crate::note::{\n    note_emission::NoteEmission,\n    note_header::NoteHeader,\n    note_interface::{NoteInterface, NullifiableNote},\n    utils::{compute_note_hash_for_nullify_internal, compute_note_hash_for_read_request},\n};\nuse crate::oracle::notes::{notify_created_note, notify_nullified_note};\n\npub fn create_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    note: &mut Note,\n) -> NoteEmission<Note>\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    let note_hash_counter = context.side_effect_counter;\n\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    let serialized_note = Note::serialize_content(*note);\n    notify_created_note(\n        storage_slot,\n        Note::get_note_type_id(),\n        serialized_note,\n        note_hash,\n        note_hash_counter,\n    );\n\n    context.push_note_hash(note_hash);\n\n    NoteEmission::new(*note)\n}\n\npub fn create_note_hash_from_public<Note, let N: u32>(\n    context: &mut PublicContext,\n    storage_slot: Field,\n    note: &mut Note,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let contract_address = (*context).this_address();\n    // Public note hashes are transient, but have no side effect counters, so we just need note_hash_counter != 0\n    let header = NoteHeader { contract_address, storage_slot, nonce: 0, note_hash_counter: 1 };\n    note.set_header(header);\n    let note_hash = note.compute_note_hash();\n\n    context.push_note_hash(note_hash);\n}\n\n// Note: This function is currently totally unused.\npub fn destroy_note<Note, let N: u32>(context: &mut PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n\n    destroy_note_unsafe(context, note, note_hash_for_read_request)\n}\n\npub fn destroy_note_unsafe<Note, let N: u32>(\n    context: &mut PrivateContext,\n    note: Note,\n    note_hash_for_read_request: Field,\n)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_nullify =\n        compute_note_hash_for_nullify_internal(note, note_hash_for_read_request);\n    let nullifier = note.compute_nullifier(context, note_hash_for_nullify);\n\n    let note_hash_counter = note.get_header().note_hash_counter;\n    let notification_note_hash = if (note_hash_counter == 0) {\n        // Counter is zero, so we're nullifying a settled note and we don't populate the note_hash with real value.\n        0\n    } else {\n        // A non-zero note hash counter implies that we're nullifying a pending note (i.e. one that has not yet been\n        // persisted in the trees and is instead in the pending new note hashes array). In such a case we populate its\n        // hash with real value to inform the kernel which note we're nullifyng so that it can either squash both\n        // the note and the nullifier if it's an inner note hash, or check that the it matches a pending note if it's\n        // a siloed note hash.\n        note_hash_for_nullify\n    };\n\n    let nullifier_counter = context.side_effect_counter;\n    notify_nullified_note(nullifier, notification_note_hash, nullifier_counter);\n\n    context.push_nullifier_for_note_hash(nullifier, notification_note_hash)\n}\n"
+    "178": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
+      "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\n// Helper fn to create a subarray from a given array\npub fn array_splice<T, let N: u32, let M: u32>(array: [T; N], offset: u32) -> [T; M]\nwhere\n    T: Empty,\n{\n    assert(M + offset <= N, \"Subarray length larger than array length\");\n    let mut result: [T; M] = [T::empty(); M];\n    for i in 0..M {\n        result[i] = array[offset + i];\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nfn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 2);\n}\n\n#[test]\nfn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concated = array_concat(array0, array1);\n    assert_eq(concated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
     },
-    "167": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/utils.nr",
-      "source": "use crate::{\n    context::PrivateContext,\n    note::{note_header::NoteHeader, note_interface::{NoteInterface, NullifiableNote}},\n    utils::array,\n};\n\nuse dep::protocol_types::hash::{\n    compute_siloed_note_hash, compute_siloed_nullifier as compute_siloed_nullifier_from_preimage,\n    compute_unique_note_hash,\n};\n\npub fn compute_siloed_nullifier<Note, let N: u32>(\n    note_with_header: Note,\n    context: &mut PrivateContext,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note_with_header.get_header();\n    let note_hash_for_nullify = compute_note_hash_for_nullify(note_with_header);\n    let inner_nullifier = note_with_header.compute_nullifier(context, note_hash_for_nullify);\n\n    compute_siloed_nullifier_from_preimage(header.contract_address, inner_nullifier)\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_read_request<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash = note.compute_note_hash();\n    let header = note.get_header();\n    let nonce = header.nonce;\n    let counter = header.note_hash_counter;\n\n    // If same tx note, read request always uses the normal note hash\n    if counter != 0 {\n        note_hash\n    } else {\n        // If the note comes from a different tx, we need to compute the note hash that reached the tree\n        compute_unique_note_hash(\n            nonce,\n            compute_siloed_note_hash(header.contract_address, note_hash),\n        )\n    }\n}\n\n// TODO(#7775): make this not impossible to understand\npub fn compute_note_hash_for_nullify_internal<Note, let N: u32>(\n    note: Note,\n    note_hash_for_read_request: Field,\n) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let header = note.get_header();\n\n    if (header.note_hash_counter != 0) & (header.nonce != 0) {\n        // Non-revertible note, nullified by a revertible nullifier, we need to nullify the note hash that will reach the tree\n        let siloed_note_hash =\n            compute_siloed_note_hash(header.contract_address, note_hash_for_read_request);\n\n        compute_unique_note_hash(header.nonce, siloed_note_hash)\n    } else {\n        note_hash_for_read_request\n    }\n}\n\n// TODO(#7775): nuke this commented out code - kept it around as it contains comments which might be helpful when tackling #7775\n// pub fn compute_note_hash_for_nullify<Note, let N: u32, let M: u32>(note: Note) -> Field where Note: NoteInterface<N> {\n//     let header = note.get_header();\n//     // There are 3 cases for reading a note intended for consumption:\n//     // 1. The note was inserted in this transaction, is revertible, or is not nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce == 0)\n//     // 2. The note was inserted in this transaction, is non-revertible, and is nullified by a revertible nullifier in\n//     //    the same transaction: (note_hash_counter != 0) & (nonce != 0)\n//     // 3. The note was inserted in a previous transaction: (note_hash_counter == 0) & (nonce != 0)\n\n//     let note_hash = note.compute_note_hiding_point().x;\n\n//     if header.nonce == 0 {\n//         // Case 1.\n//         // If a note is transient, we just read the note_hash (kernel will hash it with nonce and silo by contract address).\n//         note_hash\n//     } else {\n//         // Case 2: If a note is non-revertible, and is nullified by a revertible nullifier, we cannot squash them in the\n//         // private reset circuit. Because if the tx reverts, we will have to keep the note hash and throw away the\n//         // nullifier.\n//         // And if the tx does not revert, both will be emitted. In which case, the nullifier must be created in the app\n//         // from the siloed note hash.\n//         // The kernel circuit will check that a nullifier with non-zero note_nonce is linked to a note hash, whose\n//         // siloed note hash matches the note hash specified in the nullifier.\n\n//         // Case 3: If a note is not from the current transaction, that means we are reading a settled note (from\n//         // tree) created in a previous TX. So we need the siloed_note_hash which has already been hashed with\n//         // nonce and then contract address. This hash will match the existing leaf in the note hash\n//         // tree, so the kernel can just perform a membership check directly on this hash/leaf.\n//         let unique_note_hash = compute_unique_note_hash(header.nonce, note_hash);\n//         compute_siloed_note_hash(header.contract_address, unique_note_hash)\n//         // IMPORTANT NOTE ON REDUNDANT SILOING BY CONTRACT ADDRESS: The note hash computed above is\n//         // \"siloed\" by contract address. When a note hash is computed solely for the purpose of\n//         // nullification, it is not strictly necessary to silo the note hash before computing\n//         // its nullifier. In other words, it is NOT NECESSARY for protocol security that a nullifier\n//         // be computed from a siloed note hash. After all, persistable note hashes and nullifiers are\n//         // siloed by the kernel circuit. That being said, the siloed note hash computed above CAN be\n//         // used for nullifier computation, and this achieves the (arguably unnecessary) property that\n//         // nullifiers are computed from a note hash's fully-computed note hash tree leaf.\n//     }\n// }\n\npub fn compute_note_hash_for_nullify<Note, let N: u32>(note: Note) -> Field\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    compute_note_hash_for_nullify_internal(note, note_hash_for_read_request)\n}\n\npub unconstrained fn compute_note_hash_and_optionally_a_nullifier<T, let N: u32, let S: u32>(\n    deserialize_content: fn([Field; N]) -> T,\n    note_header: NoteHeader,\n    compute_nullifier: bool,\n    serialized_note: [Field; S],\n) -> [Field; 4]\nwhere\n    T: NoteInterface<N> + NullifiableNote,\n{\n    let mut note = deserialize_content(array::subarray(serialized_note, 0));\n    note.set_header(note_header);\n\n    let note_hash = note.compute_note_hash();\n    let siloed_note_hash = compute_siloed_note_hash(note_header.contract_address, note_hash);\n    let unique_note_hash = compute_unique_note_hash(note_header.nonce, siloed_note_hash);\n\n    let inner_nullifier = if compute_nullifier {\n        note.compute_nullifier_without_context()\n    } else {\n        0\n    };\n    // docs:start:compute_note_hash_and_optionally_a_nullifier_returns\n    [note_hash, unique_note_hash, siloed_note_hash, inner_nullifier]\n    // docs:end:compute_note_hash_and_optionally_a_nullifier_returns\n}\n"
+    "196": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
+      "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "170": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_getter/mod.nr",
-      "source": "use crate::context::PrivateContext;\nuse crate::note::{\n    constants::{GET_NOTE_ORACLE_RETURN_LENGTH, VIEW_NOTE_ORACLE_RETURN_LENGTH},\n    note_getter_options::{NoteGetterOptions, NoteStatus, PropertySelector, Select, Sort, SortOrder},\n    note_interface::{NoteInterface, NullifiableNote},\n    note_viewer_options::NoteViewerOptions,\n    utils::compute_note_hash_for_read_request,\n};\nuse crate::oracle;\nuse crate::utils::comparison::compare;\nuse dep::protocol_types::constants::{\n    GET_NOTES_ORACLE_RETURN_LENGTH, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,\n};\n\npub use crate::note::constants::MAX_NOTES_PER_PAGE;\n\nmod test;\n\nfn extract_property_value_from_selector<let N: u32>(\n    serialized_note: [Field; N],\n    selector: PropertySelector,\n) -> Field {\n    // Selectors use PropertySelectors in order to locate note properties inside the serialized note.\n    // This allows easier packing and custom (de)serialization schemas. A note property is located\n    // inside the serialized note using the index inside the array, a byte offset and a length.\n    let value: [u8; 32] = serialized_note[selector.index].to_be_bytes();\n    let offset = selector.offset;\n    let length = selector.length;\n    let mut value_field = 0 as Field;\n    let mut acc: Field = 1;\n    for i in 0..32 {\n        if i < length {\n            value_field += value[31 + offset - i] as Field * acc;\n            acc = acc * 256;\n        }\n    }\n    value_field\n}\n\nfn check_note_header<Note, let N: u32>(context: PrivateContext, storage_slot: Field, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let header = note.get_header();\n    let contract_address = context.this_address();\n    assert(header.contract_address.eq(contract_address), \"Mismatch note header contract address.\");\n    assert(header.storage_slot == storage_slot, \"Mismatch note header storage slot.\");\n}\n\nfn check_note_fields<let N: u32>(\n    serialized_note: [Field; N],\n    selects: BoundedVec<Option<Select>, N>,\n) {\n    for i in 0..selects.len() {\n        let select = selects.get_unchecked(i).unwrap_unchecked();\n        let value_field =\n            extract_property_value_from_selector(serialized_note, select.property_selector);\n\n        assert(\n            compare(value_field, select.comparator, select.value.to_field()),\n            \"Mismatch return note field.\",\n        );\n    }\n}\n\nfn check_notes_order<let N: u32>(\n    fields_0: [Field; N],\n    fields_1: [Field; N],\n    sorts: BoundedVec<Option<Sort>, N>,\n) {\n    for i in 0..sorts.len() {\n        let sort = sorts.get_unchecked(i).unwrap_unchecked();\n        let field_0 = extract_property_value_from_selector(fields_0, sort.property_selector);\n        let field_1 = extract_property_value_from_selector(fields_1, sort.property_selector);\n        let eq = field_0 == field_1;\n        let lt = field_0.lt(field_1);\n        if sort.order == SortOrder.ASC {\n            assert(eq | lt, \"Return notes not sorted in ascending order.\");\n        } else if !eq {\n            assert(!lt, \"Return notes not sorted in descending order.\");\n        }\n    }\n}\n\npub fn get_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n) -> (Note, Field)\nwhere\n    Note: NoteInterface<N> + NullifiableNote,\n{\n    let note = unsafe { get_note_internal(storage_slot) };\n\n    // Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do is check that\n    // the metadata is correct, and that the note exists.\n    check_note_header(*context, storage_slot, note);\n\n    let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n    context.push_note_hash_read_request(note_hash_for_read_request);\n\n    (note, note_hash_for_read_request)\n}\n\npub fn get_notes<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    let opt_notes = unsafe { get_notes_internal(storage_slot, options) };\n\n    // We apply the constraints in a separate function instead of inlining them here to make it easier to test that\n    // these checks correctly reject bad notes.\n    constrain_get_notes_internal(context, storage_slot, opt_notes, options)\n}\n\nunconstrained fn apply_preprocessor<Note, PREPROCESSOR_ARGS>(\n    notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor: fn([Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL], PREPROCESSOR_ARGS) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    preprocessor_args: PREPROCESSOR_ARGS,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL] {\n    preprocessor(notes, preprocessor_args)\n}\n\nfn constrain_get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    context: &mut PrivateContext,\n    storage_slot: Field,\n    opt_notes: [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL],\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n    ) -> (BoundedVec<Note, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>, BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>)\nwhere\n    Note: NoteInterface<N> + NullifiableNote + Eq,\n{\n    // The filter is applied first to avoid pushing note read requests for notes we're not interested in. Note that\n    // while the filter function can technically mutate the contents of the notes (as opposed to simply removing some),\n    // the private kernel will later validate that these note actually exist, so transformations would cause for that\n    // check to fail.\n    let filter_fn = options.filter;\n    let filter_args = options.filter_args;\n    let filtered_notes = filter_fn(opt_notes, filter_args);\n\n    let notes = crate::utils::array::collapse(filtered_notes);\n    let mut note_hashes: BoundedVec<Field, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL> =\n        BoundedVec::new();\n\n    // We have now collapsed the sparse array of Options into a BoundedVec. This is a more ergonomic type and also\n    // results in reduced gate counts when setting a limit value, since we guarantee that the limit is an upper bound\n    // for the runtime length, and can therefore have fewer loop iterations.\n    assert(notes.len() <= options.limit, \"Got more notes than limit.\");\n\n    let mut prev_fields = [0; N];\n    for i in 0..options.limit {\n        if i < notes.len() {\n            let note = notes.get_unchecked(i);\n            let fields = note.serialize_content();\n            check_note_header(*context, storage_slot, note);\n            check_note_fields(fields, options.selects);\n            if i != 0 {\n                check_notes_order(prev_fields, fields, options.sorts);\n            }\n            prev_fields = fields;\n\n            let note_hash_for_read_request = compute_note_hash_for_read_request(note);\n            // TODO(https://github.com/AztecProtocol/aztec-packages/issues/1410): test to ensure\n            // failure if malicious oracle injects 0 nonce here for a \"pre-existing\" note.\n            context.push_note_hash_read_request(note_hash_for_read_request);\n            note_hashes.push(note_hash_for_read_request);\n        };\n    }\n\n    (notes, note_hashes)\n}\n\nunconstrained fn get_note_internal<Note, let N: u32>(storage_slot: Field) -> Note\nwhere\n    Note: NoteInterface<N>,\n{\n    let placeholder_note = [Option::none()];\n    let placeholder_fields = [0; GET_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n    oracle::notes::get_notes(\n        storage_slot,\n        0,\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        1, // limit\n        0, // offset\n        NoteStatus.ACTIVE,\n        placeholder_note,\n        placeholder_fields,\n        placeholder_note_length,\n    )[0]\n        .expect(f\"Failed to get a note\") // Notice: we don't allow dummies to be returned from get_note (singular).\n}\n\nunconstrained fn get_notes_internal<Note, let N: u32, PREPROCESSOR_ARGS, FILTER_ARGS>(\n    storage_slot: Field,\n    options: NoteGetterOptions<Note, N, PREPROCESSOR_ARGS, FILTER_ARGS>,\n) -> [Option<Note>; MAX_NOTE_HASH_READ_REQUESTS_PER_CALL]\nwhere\n    Note: NoteInterface<N>,\n{\n    // This function simply performs some transformations from NoteGetterOptions into the types required by the oracle.\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTE_HASH_READ_REQUESTS_PER_CALL];\n    let placeholder_fields = [0; GET_NOTES_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let opt_notes = oracle::notes::get_notes(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    apply_preprocessor(opt_notes, options.preprocessor, options.preprocessor_args)\n}\n\npub unconstrained fn view_notes<Note, let N: u32>(\n    storage_slot: Field,\n    options: NoteViewerOptions<Note, N>,\n) -> BoundedVec<Note, MAX_NOTES_PER_PAGE>\nwhere\n    Note: NoteInterface<N>,\n{\n    let (num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values, select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order) =\n        flatten_options(options.selects, options.sorts);\n    let placeholder_opt_notes = [Option::none(); MAX_NOTES_PER_PAGE];\n    let placeholder_fields = [0; VIEW_NOTE_ORACLE_RETURN_LENGTH];\n    let placeholder_note_length = [0; N];\n\n    let notes_array = oracle::notes::get_notes(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        options.limit,\n        options.offset,\n        options.status,\n        placeholder_opt_notes,\n        placeholder_fields,\n        placeholder_note_length,\n    );\n\n    let mut notes = BoundedVec::new();\n    for i in 0..notes_array.len() {\n        if notes_array[i].is_some() {\n            notes.push(notes_array[i].unwrap_unchecked());\n        }\n    }\n\n    notes\n}\n\nunconstrained fn flatten_options<let N: u32>(\n    selects: BoundedVec<Option<Select>, N>,\n    sorts: BoundedVec<Option<Sort>, N>,\n) -> (u8, [u8; N], [u8; N], [u8; N], [Field; N], [u8; N], [u8; N], [u8; N], [u8; N], [u8; N]) {\n    let mut num_selects = 0;\n    let mut select_by_indexes = [0; N];\n    let mut select_by_offsets = [0; N];\n    let mut select_by_lengths = [0; N];\n    let mut select_values = [0; N];\n    let mut select_comparators = [0; N];\n\n    for i in 0..selects.len() {\n        let select = selects.get(i);\n        if select.is_some() {\n            select_by_indexes[num_selects] = select.unwrap_unchecked().property_selector.index;\n            select_by_offsets[num_selects] = select.unwrap_unchecked().property_selector.offset;\n            select_by_lengths[num_selects] = select.unwrap_unchecked().property_selector.length;\n            select_values[num_selects] = select.unwrap_unchecked().value;\n            select_comparators[num_selects] = select.unwrap_unchecked().comparator;\n            num_selects += 1;\n        };\n    }\n\n    let mut sort_by_indexes = [0; N];\n    let mut sort_by_offsets = [0; N];\n    let mut sort_by_lengths = [0; N];\n    let mut sort_order = [0; N];\n    for i in 0..sorts.len() {\n        let sort = sorts.get(i);\n        if sort.is_some() {\n            sort_by_indexes[i] = sort.unwrap_unchecked().property_selector.index;\n            sort_by_offsets[i] = sort.unwrap_unchecked().property_selector.offset;\n            sort_by_lengths[i] = sort.unwrap_unchecked().property_selector.length;\n            sort_order[i] = sort.unwrap_unchecked().order;\n        };\n    }\n\n    (\n        num_selects, select_by_indexes, select_by_offsets, select_by_lengths, select_values,\n        select_comparators, sort_by_indexes, sort_by_offsets, sort_by_lengths, sort_order,\n    )\n}\n"
+    "206": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/abis/validation_requests/key_validation_request.nr",
+      "source": "use crate::{point::Point, traits::{Deserialize, Empty, Serialize}};\npub use crate::constants::KEY_VALIDATION_REQUEST_LENGTH;\n\npub struct KeyValidationRequest {\n    pub pk_m: Point,\n    pub sk_app: Field, // not a grumpkin scalar because it's output of poseidon2\n}\n\nimpl Eq for KeyValidationRequest {\n    fn eq(self, request: KeyValidationRequest) -> bool {\n        (request.pk_m.eq(self.pk_m)) & (request.sk_app.eq(self.sk_app))\n    }\n}\n\nimpl Empty for KeyValidationRequest {\n    fn empty() -> Self {\n        KeyValidationRequest { pk_m: Point::empty(), sk_app: 0 }\n    }\n}\n\nimpl Serialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn serialize(self) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {\n        [self.pk_m.x, self.pk_m.y, self.pk_m.is_infinite as Field, self.sk_app]\n    }\n}\n\nimpl Deserialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn deserialize(fields: [Field; KEY_VALIDATION_REQUEST_LENGTH]) -> Self {\n        Self {\n            pk_m: Point { x: fields[0], y: fields[1], is_infinite: fields[2] as bool },\n            sk_app: fields[3],\n        }\n    }\n}\n"
     },
-    "172": {
-      "path": "/usr/src/noir-projects/aztec-nr/aztec/src/note/note_emission.nr",
-      "source": "/**\n * A note emission struct containing the information required for emitting a note.\n * The exact `emit` logic is passed in by the application code\n */\npub struct NoteEmission<Note> {\n    pub note: Note,\n}\n\nimpl<Note> NoteEmission<Note> {\n    pub fn new(note: Note) -> Self {\n        Self { note }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](Self) -> ()) {\n        _emit(self);\n    }\n\n    pub fn discard(_self: Self) {}\n}\n\n/**\n * A struct wrapping note emission in `Option<T>`.\n * This is the struct provided to application codes, which can be used to emit\n * only when a note was actually inserted.\n * It is fairly common to have cases where a function conditionally inserts,\n * and this allows us to keep the same API for emission in both cases (e.g. inserting\n * a change note in a token's transfer function only when there is \"change\" left).\n */\npub struct OuterNoteEmission<Note> {\n    emission: Option<NoteEmission<Note>>,\n}\n\nimpl<Note> OuterNoteEmission<Note> {\n    pub fn new(emission: Option<NoteEmission<Note>>) -> Self {\n        Self { emission }\n    }\n\n    pub fn emit<Env>(self, _emit: fn[Env](NoteEmission<Note>) -> ()) {\n        if self.emission.is_some() {\n            _emit(self.emission.unwrap());\n        }\n    }\n\n    pub fn discard(_self: Self) {}\n}\n"
+    "265": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr",
+      "source": "use crate::traits::{Deserialize, Serialize};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n    app_tagging_secret: Field,\n    index: u32,\n}\n\nimpl IndexedTaggingSecret {\n    pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n        poseidon2_hash(\n            [self.app_tagging_secret, recipient.to_field(), self.index as Field],\n        )\n    }\n}\n"
     },
-    "175": {
-      "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"
+    "268": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
+      "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "176": {
+    "269": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n    traits::{Deserialize, Empty, FromField, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "177": {
+    "272": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
       "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\npub struct SaltedInitializationHash {\n    pub inner: Field,\n}\n\nimpl ToField for SaltedInitializationHash {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl SaltedInitializationHash {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(salt: Field, initialization_hash: Field, deployer: AztecAddress) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
     },
-    "181": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
-      "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::GENERATOR_INDEX__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Serialize, ToField},\n};\n\nglobal PARTIAL_ADDRESS_LENGTH: u32 = 1;\n\n// Partial address\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Serialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn serialize(self: Self) -> [Field; PARTIAL_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<PARTIAL_ADDRESS_LENGTH> for PartialAddress {\n    fn deserialize(fields: [Field; PARTIAL_ADDRESS_LENGTH]) -> Self {\n        PartialAddress { inner: fields[0] }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            GENERATOR_INDEX__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
-    },
-    "182": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr",
-      "source": "use crate::traits::{Deserialize, Serialize};\nuse super::{address::aztec_address::AztecAddress, hash::poseidon2_hash};\nuse std::meta::derive;\n\npub global INDEXED_TAGGING_SECRET_LENGTH: u32 = 2;\n\n#[derive(Serialize, Deserialize)]\npub struct IndexedTaggingSecret {\n    secret: Field,\n    index: u32,\n}\n\nimpl IndexedTaggingSecret {\n    pub fn compute_tag(self, recipient: AztecAddress) -> Field {\n        poseidon2_hash([self.secret, recipient.to_field(), self.index as Field])\n    }\n}\n"
-    },
-    "183": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/contract_instance.nr",
-      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    constants::CONTRACT_INSTANCE_LENGTH,\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize},\n};\n\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Eq for ContractInstance {\n    fn eq(self, other: Self) -> bool {\n        self.public_keys.eq(other.public_keys)\n            & self.initialization_hash.eq(other.initialization_hash)\n            & self.contract_class_id.eq(other.contract_class_id)\n            & self.salt.eq(other.salt)\n    }\n}\n\nimpl Serialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn serialize(self) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n        let public_keys_serialized = self.public_keys.serialize();\n        [\n            self.salt,\n            self.deployer.to_field(),\n            self.contract_class_id.to_field(),\n            self.initialization_hash,\n            public_keys_serialized[0],\n            public_keys_serialized[1],\n            public_keys_serialized[2],\n            public_keys_serialized[3],\n            public_keys_serialized[4],\n            public_keys_serialized[5],\n            public_keys_serialized[6],\n            public_keys_serialized[7],\n            public_keys_serialized[8],\n            public_keys_serialized[9],\n            public_keys_serialized[10],\n            public_keys_serialized[11],\n        ]\n    }\n}\n\nimpl Deserialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn deserialize(serialized: [Field; CONTRACT_INSTANCE_LENGTH]) -> Self {\n        Self {\n            salt: serialized[0],\n            deployer: AztecAddress::from_field(serialized[1]),\n            contract_class_id: ContractClassId::from_field(serialized[2]),\n            initialization_hash: serialized[3],\n            public_keys: PublicKeys::deserialize([\n                serialized[4],\n                serialized[5],\n                serialized[6],\n                serialized[7],\n                serialized[8],\n                serialized[9],\n                serialized[10],\n                serialized[11],\n                serialized[12],\n                serialized[13],\n                serialized[14],\n                serialized[15],\n            ]),\n        }\n    }\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n            ),\n        )\n    }\n}\n"
-    },
-    "209": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/abis/validation_requests/key_validation_request.nr",
-      "source": "use crate::{point::Point, traits::{Deserialize, Empty, Serialize}};\npub use crate::constants::KEY_VALIDATION_REQUEST_LENGTH;\n\npub struct KeyValidationRequest {\n    pub pk_m: Point,\n    pub sk_app: Field, // not a grumpkin scalar because it's output of poseidon2\n}\n\nimpl Eq for KeyValidationRequest {\n    fn eq(self, request: KeyValidationRequest) -> bool {\n        (request.pk_m.eq(self.pk_m)) & (request.sk_app.eq(self.sk_app))\n    }\n}\n\nimpl Empty for KeyValidationRequest {\n    fn empty() -> Self {\n        KeyValidationRequest { pk_m: Point::empty(), sk_app: 0 }\n    }\n}\n\nimpl Serialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn serialize(self) -> [Field; KEY_VALIDATION_REQUEST_LENGTH] {\n        [self.pk_m.x, self.pk_m.y, self.pk_m.is_infinite as Field, self.sk_app]\n    }\n}\n\nimpl Deserialize<KEY_VALIDATION_REQUEST_LENGTH> for KeyValidationRequest {\n    fn deserialize(fields: [Field; KEY_VALIDATION_REQUEST_LENGTH]) -> Self {\n        Self {\n            pk_m: Point { x: fields[0], y: fields[1], is_infinite: fields[2] as bool },\n            sk_app: fields[3],\n        }\n    }\n}\n"
-    },
-    "241": {
-      "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"
+    "284": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> std::hash::poseidon2::Poseidon2 {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: std::hash::poseidon2::Poseidon2,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> std::hash::poseidon2::Poseidon2 {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let two_pow_64 = 18446744073709551616;\n    let empty_sponge = std::hash::poseidon2::Poseidon2::new((in_len as Field) * two_pow_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut contructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(contructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == contructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = std::hash::sha256(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "243": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/utils/arrays.nr",
-      "source": "pub mod assert_array_appended;\npub mod assert_array_prepended;\npub mod assert_combined_array;\npub mod assert_combined_transformed_array;\npub mod assert_exposed_sorted_transformed_value_array;\npub mod assert_sorted_array;\npub mod assert_sorted_transformed_value_array;\npub mod assert_split_sorted_transformed_value_arrays;\npub mod assert_split_transformed_value_arrays;\npub mod get_sorted_result;\npub mod get_sorted_tuple;\npub mod sort_by;\npub mod sort_by_counter;\n\n// Re-exports.\npub use assert_array_appended::{\n    assert_array_appended, assert_array_appended_and_scoped, assert_array_appended_reversed,\n    assert_array_appended_scoped,\n};\npub use assert_array_prepended::assert_array_prepended;\npub use assert_combined_array::{assert_combined_array, combine_arrays};\npub use assert_combined_transformed_array::{\n    assert_combined_transformed_array, combine_and_transform_arrays,\n};\npub use assert_exposed_sorted_transformed_value_array::{\n    assert_exposed_sorted_transformed_value_array,\n    get_order_hints::{get_order_hints_asc, get_order_hints_desc, OrderHint},\n};\npub use assert_sorted_array::assert_sorted_array;\npub use assert_sorted_transformed_value_array::{\n    assert_sorted_transformed_value_array, assert_sorted_transformed_value_array_capped_size,\n};\npub use assert_split_sorted_transformed_value_arrays::{\n    assert_split_sorted_transformed_value_arrays_asc,\n    assert_split_sorted_transformed_value_arrays_desc,\n    get_split_order_hints::{get_split_order_hints_asc, get_split_order_hints_desc, SplitOrderHints},\n};\npub use assert_split_transformed_value_arrays::assert_split_transformed_value_arrays;\npub use get_sorted_result::{get_sorted_result, SortedResult};\npub use sort_by_counter::{sort_by_counter_asc, sort_by_counter_desc};\n\nuse crate::traits::{Empty, is_empty};\n\npub fn subarray<let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [Field; SRC_LEN],\n    offset: u32,\n) -> [Field; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"offset too large\");\n\n    let mut dst: [Field; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\n// Helper function to convert a validated array to BoundedVec.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub unconstrained fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>\nwhere\n    T: Empty + Eq,\n{\n    let len = array_length(array);\n    BoundedVec::from_parts_unchecked(array, len)\n}\n\npub unconstrained fn find_index_hint<T, let N: u32, Env>(\n    array: [T; N],\n    find: fn[Env](T) -> bool,\n) -> u32 {\n    let mut index = N;\n    for i in 0..N {\n        if (index == N) & find(array[i]) {\n            index = i;\n        }\n    }\n    index\n}\n\n// Routine which validates that all zero values of an array form a contiguous region at the end, i.e.,\n// of the form: [*,*,*...,0,0,0,0] where any * is non-zero. Note that a full array of non-zero values is\n// valid.\npub fn validate_array<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let mut seen_empty = false;\n    let mut length = 0;\n    for i in 0..N {\n        if is_empty(array[i]) {\n            seen_empty = true;\n        } else {\n            assert(seen_empty == false, \"invalid array\");\n            length += 1;\n        }\n    }\n    length\n}\n\n// Helper function to count the number of non-empty elements in a validated array.\n// Important: Only use it for validated arrays: validate_array(array) should be true.\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    let length = unsafe { find_index_hint(array, |elem: T| is_empty(elem)) };\n    if length != 0 {\n        assert(!is_empty(array[length - 1]));\n    }\n    if length != N {\n        assert(is_empty(array[length]));\n    }\n    length\n}\n\npub fn array_concat<T, let N: u32, let M: u32>(array1: [T; N], array2: [T; M]) -> [T; N + M] {\n    let mut result = [array1[0]; N + M];\n    for i in 1..N {\n        result[i] = array1[i];\n    }\n    for i in 0..M {\n        result[i + N] = array2[i];\n    }\n    result\n}\n\npub fn array_merge<T, let N: u32>(array1: [T; N], array2: [T; N]) -> [T; N]\nwhere\n    T: Empty + Eq,\n{\n    let mut result: [T; N] = [T::empty(); N];\n    let mut i = 0;\n    for elem in array1 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    for elem in array2 {\n        if !is_empty(elem) {\n            result[i] = elem;\n            i += 1;\n        }\n    }\n    result\n}\n\npub fn check_permutation<T, let N: u32>(\n    original_array: [T; N],\n    permuted_array: [T; N],\n    original_indexes: [u32; N],\n)\nwhere\n    T: Eq + Empty,\n{\n    let mut seen_value = [false; N];\n    for i in 0..N {\n        let index = original_indexes[i];\n        let original_value = original_array[index];\n        assert(permuted_array[i].eq(original_value), \"Invalid index\");\n        assert(!seen_value[index], \"Duplicated index\");\n        seen_value[index] = true;\n    }\n}\n\n#[test]\nfn smoke_validate_array() {\n    let valid_array: [Field; 0] = [];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [0];\n    assert(validate_array(valid_array) == 0);\n\n    let valid_array = [3];\n    assert(validate_array(valid_array) == 1);\n\n    let valid_array = [1, 2, 3];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0];\n    assert(validate_array(valid_array) == 3);\n\n    let valid_array = [1, 2, 3, 0, 0];\n    assert(validate_array(valid_array) == 3);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case0() {\n    let invalid_array = [0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case1() {\n    let invalid_array = [1, 0, 0, 1, 0];\n    let _ = validate_array(invalid_array);\n}\n\n#[test(should_fail_with = \"invalid array\")]\nfn smoke_validate_array_invalid_case2() {\n    let invalid_array = [0, 0, 0, 0, 1];\n    let _ = validate_array(invalid_array);\n}\n\n#[test]\nfn test_empty_array_length() {\n    assert_eq(array_length([0]), 0);\n    assert_eq(array_length([0, 0, 0]), 0);\n}\n\n#[test]\nfn test_array_length() {\n    assert_eq(array_length([123]), 1);\n    assert_eq(array_length([123, 0, 0]), 1);\n    assert_eq(array_length([123, 456]), 2);\n    assert_eq(array_length([123, 456, 0]), 2);\n}\n\n#[test]\nfn test_array_length_invalid_arrays() {\n    // Result can be misleading (but correct) for invalid arrays.\n    assert_eq(array_length([0, 0, 123]), 0);\n    assert_eq(array_length([0, 123, 0]), 0);\n    assert_eq(array_length([0, 123, 456]), 0);\n    assert_eq(array_length([123, 0, 456]), 1);\n}\n\n#[test]\nfn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 2);\n}\n\n#[test]\nfn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = unsafe { find_index_hint(values, |v: Field| min.lt(v)) };\n    assert_eq(index, 4);\n}\n\n#[test]\nfn test_array_concat() {\n    let array0 = [1, 2, 3];\n    let array1 = [4, 5];\n    let concated = array_concat(array0, array1);\n    assert_eq(concated, [1, 2, 3, 4, 5]);\n}\n\n#[test]\nfn check_permutation_basic_test() {\n    let original_array = [1, 2, 3];\n    let permuted_array = [3, 1, 2];\n    let indexes = [2, 0, 1];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Duplicated index\")]\nfn check_permutation_duplicated_index() {\n    let original_array = [0, 1, 0];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 0];\n    check_permutation(original_array, permuted_array, indexes);\n}\n\n#[test(should_fail_with = \"Invalid index\")]\nfn check_permutation_invalid_index() {\n    let original_array = [0, 1, 2];\n    let permuted_array = [1, 0, 0];\n    let indexes = [1, 0, 2];\n    check_permutation(original_array, permuted_array, indexes);\n}\n"
+    "307": {
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
+      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "271": {
+    "308": {
       "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
       "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Serialize}};\n\npub global POINT_LENGTH: u32 = 3;\n\nimpl Serialize<POINT_LENGTH> for Point {\n    fn serialize(self: Self) -> [Field; POINT_LENGTH] {\n        [self.x, self.y, self.is_infinite as Field]\n    }\n}\n\nimpl Hash for Point {\n    fn hash(self) -> Field {\n        poseidon2_hash(self.serialize())\n    }\n}\n\nimpl Empty for Point {\n    /// Note: Does not return a valid point on curve - instead represents an empty/\"unpopulated\" point struct (e.g.\n    /// empty/unpopulated value in an array of points).\n    fn empty() -> Self {\n        Point { x: 0, y: 0, is_infinite: false }\n    }\n}\n\nimpl Deserialize<POINT_LENGTH> for Point {\n    fn deserialize(serialized: [Field; POINT_LENGTH]) -> Point {\n        Point { x: serialized[0], y: serialized[1], is_infinite: serialized[2] as bool }\n    }\n}\n"
     },
-    "309": {
-      "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"
-    },
-    "310": {
-      "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"
-    },
     "311": {
-      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::scoped::Scoped,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    traits::{is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::utils::{arrays::array_concat, field::field_from_bytes};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\nfn compute_note_hash_nonce(tx_hash: Field, note_index_in_tx: u32) -> Field {\n    // Hashing tx hash with note index in tx is guaranteed to be unique\n    poseidon2_hash_with_separator(\n        [tx_hash, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    tx_hash: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(tx_hash, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: BoundedVec<u8, 160> = BoundedVec::new();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..inputs.len() {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes.push(item_bytes[j]);\n        }\n    }\n\n    sha256_to_field(bytes.storage())\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let two_pow_64 = 18446744073709551616;\n    let iv: Field = (in_len as Field) * two_pow_64;\n    let mut sponge = std::hash::poseidon2::Poseidon2::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn 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"
+      "path": "/usr/src/noir-projects/noir-protocol-circuits/crates/types/src/contract_instance.nr",
+      "source": "use crate::{\n    address::{aztec_address::AztecAddress, partial_address::PartialAddress},\n    constants::CONTRACT_INSTANCE_LENGTH,\n    contract_class_id::ContractClassId,\n    public_keys::PublicKeys,\n    traits::{Deserialize, Hash, Serialize},\n};\n\npub struct ContractInstance {\n    pub salt: Field,\n    pub deployer: AztecAddress,\n    pub contract_class_id: ContractClassId,\n    pub initialization_hash: Field,\n    pub public_keys: PublicKeys,\n}\n\nimpl Eq for ContractInstance {\n    fn eq(self, other: Self) -> bool {\n        self.public_keys.eq(other.public_keys)\n            & self.initialization_hash.eq(other.initialization_hash)\n            & self.contract_class_id.eq(other.contract_class_id)\n            & self.salt.eq(other.salt)\n    }\n}\n\nimpl Serialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn serialize(self) -> [Field; CONTRACT_INSTANCE_LENGTH] {\n        let public_keys_serialized = self.public_keys.serialize();\n        [\n            self.salt,\n            self.deployer.to_field(),\n            self.contract_class_id.to_field(),\n            self.initialization_hash,\n            public_keys_serialized[0],\n            public_keys_serialized[1],\n            public_keys_serialized[2],\n            public_keys_serialized[3],\n            public_keys_serialized[4],\n            public_keys_serialized[5],\n            public_keys_serialized[6],\n            public_keys_serialized[7],\n            public_keys_serialized[8],\n            public_keys_serialized[9],\n            public_keys_serialized[10],\n            public_keys_serialized[11],\n        ]\n    }\n}\n\nimpl Deserialize<CONTRACT_INSTANCE_LENGTH> for ContractInstance {\n    fn deserialize(serialized: [Field; CONTRACT_INSTANCE_LENGTH]) -> Self {\n        Self {\n            salt: serialized[0],\n            deployer: AztecAddress::from_field(serialized[1]),\n            contract_class_id: ContractClassId::from_field(serialized[2]),\n            initialization_hash: serialized[3],\n            public_keys: PublicKeys::deserialize([\n                serialized[4],\n                serialized[5],\n                serialized[6],\n                serialized[7],\n                serialized[8],\n                serialized[9],\n                serialized[10],\n                serialized[11],\n                serialized[12],\n                serialized[13],\n                serialized[14],\n                serialized[15],\n            ]),\n        }\n    }\n}\n\nimpl Hash for ContractInstance {\n    fn hash(self) -> Field {\n        self.to_address().to_field()\n    }\n}\n\nimpl ContractInstance {\n    pub fn to_address(self) -> AztecAddress {\n        AztecAddress::compute(\n            self.public_keys,\n            PartialAddress::compute(\n                self.contract_class_id,\n                self.salt,\n                self.initialization_hash,\n                self.deployer,\n            ),\n        )\n    }\n}\n"
     },
-    "317": {
+    "320": {
       "path": "/root/nargo/github.com/noir-lang/ec/v0.1.2/src/lib.nr",
       "source": "// Elliptic curve implementation\n// Overview\n// ========\n// The following three elliptic curve representations are admissible:\npub mod tecurve; // Twisted Edwards curves\npub mod swcurve; // Elliptic curves in Short Weierstrass form\npub mod montcurve; // Montgomery curves\npub mod consts; // Commonly used curve presets\n//\n// Note that Twisted Edwards and Montgomery curves are (birationally) equivalent, so that\n// they may be freely converted between one another, whereas Short Weierstrass curves are\n// more general. Diagramatically:\n//\n// tecurve == montcurve `subset` swcurve\n//\n// Each module is further divided into two submodules, 'affine' and 'curvegroup', depending\n// on the preferred coordinate representation. Affine coordinates are none other than the usual\n// two-dimensional Cartesian coordinates used in the definitions of these curves, whereas\n// 'CurveGroup' coordinates (terminology borrowed from Arkworks, whose conventions we try\n// to follow) are special coordinate systems with respect to which the group operations may be\n// implemented more efficiently, usually by means of an appropriate choice of projective coordinates.\n//\n// In each of these submodules, there is a Point struct and a Curve struct, the former\n// representing a point in the coordinate system and the latter a curve configuration.\n//\n// Points\n// ======\n// Points may be instantiated using the associated function `new`, which takes coordinates\n// as its arguments. For instance,\n//\n// `let p = swcurve::Point::new(1,1);`\n//\n// The additive identity may be constructed by a call to the associated function `zero` of no\n// arguments:\n//\n// `let zero = swcurve::Point::zero();`\n//\n// Points may be tested for equality by calling the method `eq`:\n//\n// `let pred = p.eq(zero);`\n//\n// There is also the method `is_zero` to explicitly check whether a point is the additive identity:\n//\n// `constrain pred == p.is_zero();`\n//\n// Points may be negated by calling the `negate` method and converted to CurveGroup (or affine)\n// coordinates by calling the `into_group` (resp. `into_affine`) method on them. Finally,\n// Points may be freely mapped between their respective Twisted Edwards and Montgomery\n// representations by calling the `into_montcurve` or `into_tecurve` methods. For mappings\n// between Twisted Edwards/Montgomery curves and Short Weierstrass curves, see the Curve section\n// below, as the underlying mappings are those of curves rather than ambient spaces.\n// As a rule, Points in affine (or CurveGroup) coordinates are mapped to Points in affine\n// (resp. CurveGroup) coordinates.\n//\n// Curves\n// ======\n// A curve configuration (Curve) is completely determined by the Field coefficients of its defining\n// equation (a and b in the case of swcurve, a and d in the case of tecurve, and j and k in\n// the case of montcurve) together with a generator (`gen`) in the corresponding coordinate system.\n// For example, the Baby Jubjub curve configuration as defined in ERC-2494 may be instantiated as a Twisted\n// Edwards curve in affine coordinates as follows:\n//\n// `let bjj_affine = tecurve::Curve::new(168700, 168696, tecurve::Point::new(995203441582195749578291179787384436505546430278305826713579947235728471134,5472060717959818805561601436314318772137091100104008585924551046643952123905));`\n//\n// The `contains` method may be used to check whether a Point lies on a given curve:\n//\n// `constrain bjj_affine.contains(tecurve::Point::zero());`\n//\n// The elliptic curve group's addition operation is exposed as the `add` method, e.g.\n//\n// `let p = bjj_affine.add(bjj_affine.gen, bjj_affine.gen);`\n//\n// subtraction as the `subtract` method, e.g.\n//\n// `constrain tecurve::Point::zero().eq(bjj_affine.subtract(bjj_affine.gen, bjj_affine.gen));`\n//\n// scalar multiplication as the `mul` method, where the scalar is assumed to be a Field* element, e.g.\n//\n// `constrain tecurve::Point::zero().eq(bjj_affine.mul(2, tecurve::Point::zero());`\n//\n// There is a scalar multiplication method (`bit_mul`) provided where the scalar input is expected to be\n// an array of bits (little-endian convention), as well as a multi-scalar multiplication method** (`msm`)\n// which takes an array of Field elements and an array of elliptic curve points as arguments, both assumed\n// to be of the same length.\n//\n// Curve configurations may be converted between different coordinate representations by calling the `into_group`\n// and `into_affine` methods on them, e.g.\n//\n// `let bjj_curvegroup = bjj_affine.into_group();`\n//\n// Curve configurations may also be converted between different curve representations by calling the `into_swcurve`,\n// `into_montcurve` and `into_tecurve` methods subject to the relation between the curve representations mentioned\n// above. Note that it is possible to map Points from a Twisted Edwards/Montgomery curve to the corresponding\n// Short Weierstrass representation and back, and the methods to do so are exposed as `map_into_swcurve` and\n// `map_from_swcurve`, which each take one argument, the point to be mapped.\n//\n// Curve maps\n// ==========\n// There are a few different ways of mapping Field elements to elliptic curves. Here we provide the simplified\n// Shallue-van de Woestijne-Ulas and Elligator 2 methods, the former being applicable to all curve types\n// provided above subject to the constraint that the coefficients of the corresponding Short Weierstrass curve satisfies\n// a*b != 0 and the latter being applicable to Montgomery and Twisted Edwards curves subject to the constraint that\n// the coefficients of the corresponding Montgomery curve satisfy j*k != 0 and (j^2 - 4)/k^2 is non-square.\n//\n// The simplified Shallue-van de Woestijne-Ulas method is exposed as the method `swu_map` on the Curve configuration and\n// depends on two parameters, a Field element z != -1 for which g(x) - z is irreducible over Field and g(b/(z*a)) is\n// square, where g(x) = x^3 + a*x + b is the right-hand side of the defining equation of the corresponding Short\n// Weierstrass curve, and a Field element u to be mapped onto the curve. For example, in the case of bjj_affine above,\n// it may be determined using the scripts provided at <https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve> that z = 5.\n//\n// The Elligator 2 method is exposed as the method `elligator2_map` on the Curve configurations of Montgomery and\n// Twisted Edwards curves. Like the simplified SWU method above, it depends on a certain non-square element of Field,\n// but this element need not satisfy any further conditions, so it is included as the (Field-dependent) constant\n//`ZETA` below. Thus, the `elligator2_map` method depends only on one parameter, the Field element to be mapped onto\n// the curve.\n//\n// For details on all of the above in the context of hashing to elliptic curves, see <https://datatracker.ietf.org/doc/id/draft-irtf-cfrg-hash-to-curve-06.html>.\n//\n//\n// *TODO: Replace Field with Bigint.\n// **TODO: Support arrays of structs to make this work.\n// Field-dependent constant ZETA = a non-square element of Field\n// Required for Elligator 2 map\n// TODO: Replace with built-in constant.\nglobal ZETA: Field = 5;\n// Field-dependent constants for Tonelli-Shanks algorithm (see sqrt function below)\n// TODO: Possibly make this built-in.\nglobal C1: u32 = 28;\nglobal C3: Field = 40770029410420498293352137776570907027550720424234931066070132305055;\nglobal C5: Field = 19103219067921713944291392827692070036145651957329286315305642004821462161904;\n// Higher-order version of scalar multiplication\n// TODO: Make this work so that the submodules' bit_mul may be defined in terms of it.\n//fn bit_mul<T,N>(add: fn(T,T) -> T, e: T, bits: [u1; N], p: T) -> T {\n//    let mut out = e;\n//    let n = bits.len();\n//\n//    for i in 0..n {\n//        out = add(\n//            add(out, out),\n//            if(bits[n - i - 1] == 0) {e} else {p});\n//    }\n//\n//    out\n//}\n// TODO: Make this built-in.\npub fn safe_inverse(x: Field) -> Field {\n    if x == 0 {\n        0\n    } else {\n        1 / x\n    }\n}\n// Boolean indicating whether Field element is a square, i.e. whether there exists a y in Field s.t. x = y*y.\npub fn is_square(x: Field) -> bool {\n    let v = pow(x, 0 - 1 / 2);\n\n    v * (v - 1) == 0\n}\n// Power function of two Field arguments of arbitrary size.\n// Adapted from std::field::pow_32.\npub fn pow(x: Field, y: Field) -> Field {\n    let mut r = 1 as Field;\n    let b: [u1; 254] = y.to_le_bits();\n\n    for i in 0..254 {\n        r *= r;\n        r *= (b[254 - 1 - i] as Field) * x + (1 - b[254 - 1 - i] as Field);\n    }\n\n    r\n}\n// Tonelli-Shanks algorithm for computing the square root of a Field element.\n// Requires C1 = max{c: 2^c divides (p-1)}, where p is the order of Field\n// as well as C3 = (C2 - 1)/2, where C2 = (p-1)/(2^c1),\n// and C5 = ZETA^C2, where ZETA is a non-square element of Field.\n// These are pre-computed above as globals.\npub fn sqrt(x: Field) -> Field {\n    let mut z = pow(x, C3);\n    let mut t = z * z * x;\n    z *= x;\n    let mut b = t;\n    let mut c = C5;\n\n    for i in 0..(C1 - 1) {\n        for _j in 1..(C1 - i - 1) {\n            b *= b;\n        }\n\n        z *= if b == 1 { 1 } else { c };\n\n        c *= c;\n\n        t *= if b == 1 { 1 } else { c };\n\n        b = t;\n    }\n\n    z\n}\n\nmod tests {\n    use crate::montcurve::affine::Point as MGaffine;\n    use crate::montcurve::curvegroup::Point as MG;\n    use crate::swcurve::affine::Point as SWGaffine;\n    use crate::swcurve::curvegroup::Point as SWG;\n    use crate::tecurve::affine::Curve as AffineCurve;\n    use crate::tecurve::affine::Point as Gaffine;\n    use crate::tecurve::curvegroup::Point as G;\n\n    #[test]\n    fn smoke_test() {\n        // Tests may be checked against https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve/tree/main/poc\n        // Define Baby Jubjub (ERC-2494) parameters in affine representation\n        let bjj_affine = AffineCurve::new(\n            168700,\n            168696,\n            Gaffine::new(\n                995203441582195749578291179787384436505546430278305826713579947235728471134,\n                5472060717959818805561601436314318772137091100104008585924551046643952123905,\n            ),\n        );\n        // Test addition\n        let p1_affine = Gaffine::new(\n            17777552123799933955779906779655732241715742912184938656739573121738514868268,\n            2626589144620713026669568689430873010625803728049924121243784502389097019475,\n        );\n        let p2_affine = Gaffine::new(\n            16540640123574156134436876038791482806971768689494387082833631921987005038935,\n            20819045374670962167435360035096875258406992893633759881276124905556507972311,\n        );\n\n        let p3_affine = bjj_affine.add(p1_affine, p2_affine);\n        assert(p3_affine.eq(Gaffine::new(\n            7916061937171219682591368294088513039687205273691143098332585753343424131937,\n            14035240266687799601661095864649209771790948434046947201833777492504781204499,\n        )));\n        // Test scalar multiplication\n        let p4_affine = bjj_affine.mul(2, p1_affine);\n        assert(p4_affine.eq(Gaffine::new(\n            6890855772600357754907169075114257697580319025794532037257385534741338397365,\n            4338620300185947561074059802482547481416142213883829469920100239455078257889,\n        )));\n        assert(p4_affine.eq(bjj_affine.bit_mul([0, 1], p1_affine)));\n        // Test subtraction\n        let p5_affine = bjj_affine.subtract(p3_affine, p3_affine);\n        assert(p5_affine.eq(Gaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_affine.contains(bjj_affine.gen)\n                & bjj_affine.contains(p1_affine)\n                & bjj_affine.contains(p2_affine)\n                & bjj_affine.contains(p3_affine)\n                & bjj_affine.contains(p4_affine)\n                & bjj_affine.contains(p5_affine),\n        );\n        // Test CurveGroup equivalents\n        let bjj = bjj_affine.into_group(); // Baby Jubjub\n        let p1 = p1_affine.into_group();\n        let p2 = p2_affine.into_group();\n        let p3 = p3_affine.into_group();\n        let p4 = p4_affine.into_group();\n        let p5 = p5_affine.into_group();\n        // Test addition\n        assert(p3.eq(bjj.add(p1, p2)));\n        // Test scalar multiplication\n        assert(p4.eq(bjj.mul(2, p1)));\n        assert(p4.eq(bjj.bit_mul([0, 1], p1)));\n        // Test subtraction\n        assert(G::zero().eq(bjj.subtract(p3, p3)));\n        assert(p5.eq(G::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj.contains(bjj.gen)\n                & bjj.contains(p1)\n                & bjj.contains(p2)\n                & bjj.contains(p3)\n                & bjj.contains(p4)\n                & bjj.contains(p5),\n        );\n        // Test SWCurve equivalents of the above\n        // First the affine representation\n        let bjj_swcurve_affine = bjj_affine.into_swcurve();\n\n        let p1_swcurve_affine = bjj_affine.map_into_swcurve(p1_affine);\n        let p2_swcurve_affine = bjj_affine.map_into_swcurve(p2_affine);\n        let p3_swcurve_affine = bjj_affine.map_into_swcurve(p3_affine);\n        let p4_swcurve_affine = bjj_affine.map_into_swcurve(p4_affine);\n        let p5_swcurve_affine = bjj_affine.map_into_swcurve(p5_affine);\n        // Addition\n        assert(p3_swcurve_affine.eq(bjj_swcurve_affine.add(p1_swcurve_affine, p2_swcurve_affine)));\n        // Doubling\n        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.mul(2, p1_swcurve_affine)));\n        assert(p4_swcurve_affine.eq(bjj_swcurve_affine.bit_mul([0, 1], p1_swcurve_affine)));\n        // Subtraction\n        assert(SWGaffine::zero().eq(bjj_swcurve_affine.subtract(\n            p3_swcurve_affine,\n            p3_swcurve_affine,\n        )));\n        assert(p5_swcurve_affine.eq(SWGaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_swcurve_affine.contains(bjj_swcurve_affine.gen)\n                & bjj_swcurve_affine.contains(p1_swcurve_affine)\n                & bjj_swcurve_affine.contains(p2_swcurve_affine)\n                & bjj_swcurve_affine.contains(p3_swcurve_affine)\n                & bjj_swcurve_affine.contains(p4_swcurve_affine)\n                & bjj_swcurve_affine.contains(p5_swcurve_affine),\n        );\n        // Then the CurveGroup representation\n        let bjj_swcurve = bjj.into_swcurve();\n\n        let p1_swcurve = bjj.map_into_swcurve(p1);\n        let p2_swcurve = bjj.map_into_swcurve(p2);\n        let p3_swcurve = bjj.map_into_swcurve(p3);\n        let p4_swcurve = bjj.map_into_swcurve(p4);\n        let p5_swcurve = bjj.map_into_swcurve(p5);\n        // Addition\n        assert(p3_swcurve.eq(bjj_swcurve.add(p1_swcurve, p2_swcurve)));\n        // Doubling\n        assert(p4_swcurve.eq(bjj_swcurve.mul(2, p1_swcurve)));\n        assert(p4_swcurve.eq(bjj_swcurve.bit_mul([0, 1], p1_swcurve)));\n        // Subtraction\n        assert(SWG::zero().eq(bjj_swcurve.subtract(p3_swcurve, p3_swcurve)));\n        assert(p5_swcurve.eq(SWG::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_swcurve.contains(bjj_swcurve.gen)\n                & bjj_swcurve.contains(p1_swcurve)\n                & bjj_swcurve.contains(p2_swcurve)\n                & bjj_swcurve.contains(p3_swcurve)\n                & bjj_swcurve.contains(p4_swcurve)\n                & bjj_swcurve.contains(p5_swcurve),\n        );\n        // Test MontCurve conversions\n        // First the affine representation\n        let bjj_montcurve_affine = bjj_affine.into_montcurve();\n\n        let p1_montcurve_affine = p1_affine.into_montcurve();\n        let p2_montcurve_affine = p2_affine.into_montcurve();\n        let p3_montcurve_affine = p3_affine.into_montcurve();\n        let p4_montcurve_affine = p4_affine.into_montcurve();\n        let p5_montcurve_affine = p5_affine.into_montcurve();\n        // Addition\n        assert(p3_montcurve_affine.eq(bjj_montcurve_affine.add(\n            p1_montcurve_affine,\n            p2_montcurve_affine,\n        )));\n        // Doubling\n        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.mul(2, p1_montcurve_affine)));\n        assert(p4_montcurve_affine.eq(bjj_montcurve_affine.bit_mul([0, 1], p1_montcurve_affine)));\n        // Subtraction\n        assert(MGaffine::zero().eq(bjj_montcurve_affine.subtract(\n            p3_montcurve_affine,\n            p3_montcurve_affine,\n        )));\n        assert(p5_montcurve_affine.eq(MGaffine::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_montcurve_affine.contains(bjj_montcurve_affine.gen)\n                & bjj_montcurve_affine.contains(p1_montcurve_affine)\n                & bjj_montcurve_affine.contains(p2_montcurve_affine)\n                & bjj_montcurve_affine.contains(p3_montcurve_affine)\n                & bjj_montcurve_affine.contains(p4_montcurve_affine)\n                & bjj_montcurve_affine.contains(p5_montcurve_affine),\n        );\n        // Then the CurveGroup representation\n        let bjj_montcurve = bjj.into_montcurve();\n\n        let p1_montcurve = p1_montcurve_affine.into_group();\n        let p2_montcurve = p2_montcurve_affine.into_group();\n        let p3_montcurve = p3_montcurve_affine.into_group();\n        let p4_montcurve = p4_montcurve_affine.into_group();\n        let p5_montcurve = p5_montcurve_affine.into_group();\n        // Addition\n        assert(p3_montcurve.eq(bjj_montcurve.add(p1_montcurve, p2_montcurve)));\n        // Doubling\n        assert(p4_montcurve.eq(bjj_montcurve.mul(2, p1_montcurve)));\n        assert(p4_montcurve.eq(bjj_montcurve.bit_mul([0, 1], p1_montcurve)));\n        // Subtraction\n        assert(MG::zero().eq(bjj_montcurve.subtract(p3_montcurve, p3_montcurve)));\n        assert(p5_montcurve.eq(MG::zero()));\n        // Check that these points are on the curve\n        assert(\n            bjj_montcurve.contains(bjj_montcurve.gen)\n                & bjj_montcurve.contains(p1_montcurve)\n                & bjj_montcurve.contains(p2_montcurve)\n                & bjj_montcurve.contains(p3_montcurve)\n                & bjj_montcurve.contains(p4_montcurve)\n                & bjj_montcurve.contains(p5_montcurve),\n        );\n        // Elligator 2 map-to-curve\n        let ell2_pt_map = bjj_affine.elligator2_map(27);\n\n        assert(ell2_pt_map.eq(MGaffine::new(\n            7972459279704486422145701269802978968072470631857513331988813812334797879121,\n            8142420778878030219043334189293412482212146646099536952861607542822144507872,\n        )\n            .into_tecurve()));\n        // SWU map-to-curve\n        let swu_pt_map = bjj_affine.swu_map(5, 27);\n\n        assert(swu_pt_map.eq(bjj_affine.map_from_swcurve(SWGaffine::new(\n            2162719247815120009132293839392097468339661471129795280520343931405114293888,\n            5341392251743377373758788728206293080122949448990104760111875914082289313973,\n        ))));\n    }\n\n}\n"
     },
-    "336": {
-      "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"
+    "339": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/account.nr",
+      "source": "use dep::aztec::{\n    context::PrivateContext,\n    hash::poseidon2_hash_with_separator,\n    protocol_types::constants::{GENERATOR_INDEX__COMBINED_PAYLOAD, GENERATOR_INDEX__TX_NULLIFIER},\n};\n\nuse crate::auth::{compute_authwit_message_hash, IS_VALID_SELECTOR};\nuse crate::entrypoint::{app::AppPayload, fee::FeePayload};\n\npub struct AccountActions<Context> {\n    context: Context,\n    is_valid_impl: fn(&mut PrivateContext, Field) -> bool,\n}\n\nimpl<Context> AccountActions<Context> {\n    pub fn init(context: Context, is_valid_impl: fn(&mut PrivateContext, Field) -> bool) -> Self {\n        AccountActions { context, is_valid_impl }\n    }\n}\n\n/**\n * An implementation of the Account Action struct for the private context.\n *\n * Implements logic to verify authorization and execute payloads.\n */\nimpl AccountActions<&mut PrivateContext> {\n\n    /**\n     * Verifies that the `app_hash` and `fee_hash` are authorized and then executes them.\n     *\n     * Executes the `fee_payload` and `app_payload` in sequence.\n     * Will execute the `fee_payload` as part of the setup, and then enter the app phase.\n     *\n     * @param app_payload The payload that contains the calls to be executed in the app phase.\n     * @param fee_payload The payload that contains the calls to be executed in the setup phase.\n     */\n    // docs:start:entrypoint\n    pub fn entrypoint(self, app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let valid_fn = self.is_valid_impl;\n\n        let combined_payload_hash = poseidon2_hash_with_separator(\n            [app_payload.hash(), fee_payload.hash()],\n            GENERATOR_INDEX__COMBINED_PAYLOAD,\n        );\n        assert(valid_fn(self.context, combined_payload_hash));\n\n        fee_payload.execute_calls(self.context);\n        self.context.end_setup();\n        app_payload.execute_calls(self.context);\n        if cancellable {\n            let tx_nullifier =\n                poseidon2_hash_with_separator([app_payload.nonce], GENERATOR_INDEX__TX_NULLIFIER);\n            self.context.push_nullifier(tx_nullifier);\n        }\n    }\n    // docs:end:entrypoint\n\n    /**\n     * Verifies that the `msg_sender` is authorized to consume `inner_hash` by the account.\n     *\n     * Computes the `message_hash` using the `msg_sender`, `chain_id`, `version` and `inner_hash`.\n     * Then executes the `is_valid_impl` function to verify that the message is authorized.\n     *\n     * Will revert if the message is not authorized.\n     *\n     * @param inner_hash The hash of the message that the `msg_sender` is trying to consume.\n     */\n    // docs:start:verify_private_authwit\n    pub fn verify_private_authwit(self, inner_hash: Field) -> Field {\n        // The `inner_hash` is \"siloed\" with the `msg_sender` to ensure that only it can\n        // consume the message.\n        // This ensures that contracts cannot consume messages that are not intended for them.\n        let message_hash = compute_authwit_message_hash(\n            self.context.msg_sender(),\n            self.context.chain_id(),\n            self.context.version(),\n            inner_hash,\n        );\n        let valid_fn = self.is_valid_impl;\n        assert(valid_fn(self.context, message_hash) == true, \"Message not authorized by account\");\n        IS_VALID_SELECTOR\n    }\n    // docs:end:verify_private_authwit\n}\n"
     },
-    "337": {
+    "340": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/app.nr",
       "source": "use dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__SIGNATURE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\nuse crate::entrypoint::function_call::FunctionCall;\n\n// FUNCTION_CALL_SIZE * ACCOUNT_MAX_CALLS + 1\nglobal APP_PAYLOAD_SIZE: u32 = 21;\n// FUNCTION_CALL_SIZE_IN_BYTES * ACCOUNT_MAX_CALLS + 32\nglobal APP_PAYLOAD_SIZE_IN_BYTES: u32 = 424;\n\nglobal ACCOUNT_MAX_CALLS: u32 = 4;\n\n// Note: If you change the following struct you have to update default_entrypoint.ts\n// docs:start:app-payload-struct\npub struct AppPayload {\n    function_calls: [FunctionCall; ACCOUNT_MAX_CALLS],\n    nonce: Field,\n}\n// docs:end:app-payload-struct\n\nimpl Serialize<APP_PAYLOAD_SIZE> for AppPayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; APP_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, APP_PAYLOAD_SIZE> = BoundedVec::new();\n        for call in self.function_calls {\n            fields.extend_from_array(call.serialize());\n        }\n        fields.push(self.nonce);\n        fields.storage()\n    }\n}\n\nimpl Hash for AppPayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__SIGNATURE_PAYLOAD)\n    }\n}\n\nimpl AppPayload {\n    // Serializes the payload as an array of bytes. Useful for hashing with sha256.\n    fn to_be_bytes(self) -> [u8; APP_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, APP_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..ACCOUNT_MAX_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n\n        bytes.storage()\n    }\n\n    // Executes all private and public calls\n    // docs:start:entrypoint-execute-calls\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n    }\n    // docs:end:entrypoint-execute-calls\n}\n"
     },
-    "340": {
-      "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"
+    "341": {
+      "path": "/usr/src/noir-projects/aztec-nr/authwit/src/entrypoint/fee.nr",
+      "source": "use crate::entrypoint::function_call::FunctionCall;\nuse dep::aztec::prelude::PrivateContext;\nuse dep::aztec::protocol_types::{\n    constants::GENERATOR_INDEX__FEE_PAYLOAD,\n    hash::poseidon2_hash_with_separator,\n    traits::{Hash, Serialize},\n};\n\n// 2 * 5 (FUNCTION_CALL_SIZE) + 2\nglobal FEE_PAYLOAD_SIZE: u32 = 12;\n\n// 2 * 98 (FUNCTION_CALL_SIZE_IN_BYTES) + 32\nglobal FEE_PAYLOAD_SIZE_IN_BYTES: u32 = 228;\n\nglobal MAX_FEE_FUNCTION_CALLS: u32 = 2;\n\n// docs:start:fee-payload-struct\npub struct FeePayload {\n    function_calls: [FunctionCall; MAX_FEE_FUNCTION_CALLS],\n    nonce: Field,\n    is_fee_payer: bool,\n}\n// docs:end:fee-payload-struct\n\nimpl Serialize<FEE_PAYLOAD_SIZE> for FeePayload {\n    // Serializes the entrypoint struct\n    fn serialize(self) -> [Field; FEE_PAYLOAD_SIZE] {\n        let mut fields: BoundedVec<Field, FEE_PAYLOAD_SIZE> = BoundedVec::new();\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            fields.extend_from_array(self.function_calls[i].serialize());\n        }\n        fields.push(self.nonce);\n        fields.push(self.is_fee_payer as Field);\n        fields.storage()\n    }\n}\n\nimpl Hash for FeePayload {\n    fn hash(self) -> Field {\n        poseidon2_hash_with_separator(self.serialize(), GENERATOR_INDEX__FEE_PAYLOAD)\n    }\n}\n\nimpl FeePayload {\n    fn to_be_bytes(self) -> [u8; FEE_PAYLOAD_SIZE_IN_BYTES] {\n        let mut bytes: BoundedVec<u8, FEE_PAYLOAD_SIZE_IN_BYTES> = BoundedVec::new();\n\n        for i in 0..MAX_FEE_FUNCTION_CALLS {\n            bytes.extend_from_array(self.function_calls[i].to_be_bytes());\n        }\n        bytes.extend_from_array(self.nonce.to_be_bytes::<32>());\n        bytes.push(self.is_fee_payer as u8);\n\n        bytes.storage()\n    }\n\n    fn execute_calls(self, context: &mut PrivateContext) {\n        for call in self.function_calls {\n            if !call.target_address.is_zero() {\n                if call.is_public {\n                    context.call_public_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                } else {\n                    let _result = context.call_private_function_with_packed_args(\n                        call.target_address,\n                        call.function_selector,\n                        call.args_hash,\n                        call.is_static,\n                    );\n                }\n            }\n        }\n        if self.is_fee_payer {\n            context.set_as_fee_payer();\n        }\n    }\n}\n"
     },
-    "342": {
+    "344": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth_witness.nr",
       "source": "#[oracle(getAuthWitness)]\nunconstrained fn get_auth_witness_oracle<let N: u32>(_message_hash: Field) -> [Field; N] {}\n\n/**\n * Oracle wrapper to fetch an `auth_witness` for a given `message_hash` from the PXE.\n *\n * @param message_hash The hash of the message for which the `auth_witness` is to be fetched.\n * @return The `auth_witness` for the given `message_hash` as Field array.\n */\npub unconstrained fn get_auth_witness<let N: u32>(message_hash: Field) -> [Field; N] {\n    get_auth_witness_oracle(message_hash)\n}\n"
     },
-    "343": {
+    "345": {
       "path": "/usr/src/noir-projects/aztec-nr/authwit/src/auth.nr",
       "source": "use dep::aztec::{context::{gas::GasOpts, PrivateContext, PublicContext}, hash::hash_args_array};\nuse dep::aztec::protocol_types::{\n    abis::function_selector::FunctionSelector,\n    address::AztecAddress,\n    constants::{\n        CANONICAL_AUTH_REGISTRY_ADDRESS, GENERATOR_INDEX__AUTHWIT_INNER,\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER, GENERATOR_INDEX__AUTHWIT_OUTER,\n    },\n    hash::poseidon2_hash_with_separator,\n};\n\n/**\n * Authenticaion witness helper library\n *\n * Authentication Witness is a scheme for authenticating actions on Aztec, so users can allow third-parties\n * (e.g. protocols or other users) to execute an action on their behalf.\n *\n * This library provides helper functions to manage such witnesses.\n * The authentication witness, is some \"witness\" (data) that authenticates a `message_hash`.\n * The simplest example of an authentication witness, is a signature. The signature is the \"evidence\",\n * that the signer has seen the message, agrees with it, and has allowed it.\n * It does not need to be a signature. It could be any kind of \"proof\" that the message is allowed.\n * Another proof could be knowing some kind of secret, or having some kind of \"token\" that allows the message.\n *\n * The `message_hash` is a hash of the following structure:\n * hash(consumer, chain_id, version, inner_hash)\n * - consumer: the address of the contract that is \"consuming\" the message,\n * - chain_id: the chain id of the chain that the message is being consumed on,\n * - version: the version of the chain that the message is being consumed on,\n * - inner_hash: the hash of the \"inner\" message that is being consumed, this is the \"actual\" message or action.\n *\n * While the `inner_hash` could be anything, such as showing you signed a specific message, it will often be\n * a hash of the \"action\" to approve, along with who made the call. As part of this library, we provide a few\n * helper functions to deal with such messages.\n *\n * For example, we provide helper function that is used for checking that the message is an encoding of the current call.\n * This can be used to let some contract \"allow\" another contract to act on its behalf, as long as it can\n * show that it is acting on behalf of the contract.\n *\n * If we take a case of allowing a contract to transfer tokens on behalf of an account, the `inner_hash` can be\n * derived as:\n * inner_hash = hash(caller, \"transfer\", hash(to, amount))\n *\n * Where the `caller` would be the address of the contract that is trying to transfer the tokens, and `to` and `amount`\n * the arguments for the transfer.\n *\n * Note that we have both a `caller` and a `consumer`, the `consumer` will be the contract that is consuming the message,\n * in the case of the transfer, it would be the `Token` contract itself, while the caller, will be the actor that is\n * allowed to transfer the tokens.\n *\n *\n * The authentication mechanism works differently in public and private contexts. In private, we recall that everything\n * is executed on the user's device, so we can use `oracles` to \"ask\" the user (not contract) for information. In public\n * we cannot do this, since it is executed by the sequencer (someone else). Therefore we can instead use a \"registry\"\n * to store the messages that we have approved.\n *\n * A simple example would be a \"token\" that is being \"pulled\" from one account into another. We will first outline\n * how this would look in private, and then in public later.\n *\n * Say that a user `Alice` wants to deposit some tokens into a DeFi protocol (say a DEX).\n * `Alice` would make a `deposit` transaction, that she is executing using her account contract.\n * The account would call the `DeFi` contract to execute `deposit`, which would try to pull funds from the `Token`\n * contract. Since the `DeFi` contract is trying to pull funds from an account that is not its own, it needs to\n * convince the `Token` contract that it is allowed to do so.\n *\n * This is where the authentication witness comes in The `Token` contract computes a `message_hash` from the\n * `transfer` call, and then asks `Alice Account` contract to verify that the `DeFi` contract is allowed to\n * execute that call.\n *\n * `Alice Account` contract can then ask `Alice` if she wants to allow the `DeFi` contract to pull funds from her\n * account. If she does, she will sign the `message_hash` and return the signature to the `Alice Account` which\n * will validate it and return success to the `Token` contract which will then allow the `DeFi` contract to pull\n * funds from `Alice`.\n *\n * To ensure that the same \"approval\" cannot be used multiple times, we also compute a `nullifier` for the\n * authentication witness, and emit it from the `Token` contract (consumer).\n *\n * Note that we can do this flow as we are in private were we can do oracle calls out from contracts.\n *\n *\n *  Person          Contract              Contract               Contract\n *  Alice          Alice Account          Token                   DeFi\n *   |                  |                  |                      |\n *   | Defi.deposit(Token, 1000)           |                      |\n *   |----------------->|                  |                      |\n *   |                  | deposit(Token, 1000)                    |\n *   |                  |---------------------------------------->|\n *   |                  |                  |                      |\n *   |                  |                  | transfer(Alice, Defi, 1000)\n *   |                  |                  |<---------------------|\n *   |                  |                  |                      |\n *   |                  | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |<-----------------|                      |\n *   |                  |                  |                      |\n *   | Please give me AuthWit for DeFi     |                      |\n *   | calling transfer(Alice, Defi, 1000) |                      |\n *   |<-----------------|                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   | AuthWit for transfer(Alice, Defi, 1000)                    |\n *   |----------------->|                  |                      |\n *   |                  | AuthWit validity |                      |\n *   |                  |----------------->|                      |\n *   |                  |                  |                      |\n *   |                  |       throw if invalid AuthWit          |\n *   |                  |                  |                      |\n *   |                  |       emit AuthWit nullifier            |\n *   |                  |                  |                      |\n *   |                  |       transfer(Alice, Defi, 1000)       |\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  | success              |\n *   |                  |                  |--------------------->|\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *   |                  |                  |           deposit(Token, 1000)\n *   |                  |                  |                      |\n *   |                  |                  |                      |\n *\n *\n * If we instead were in public, we cannot do the same flow. Instead we would use an authentication registry to store\n * the messages that we have approved.\n *\n * To approve a message, `Alice Account` can make a `set_authorized` call to the registry, to set a `message_hash`\n * as authorized. This is essentially a mapping from `message_hash` to `true` for `Alice Contract`. Every account\n * has its own map in the registry, so `Alice` cannot approve a message for `Bob`.\n *\n * The `Token` contract can then try to \"spend\" the approval by calling `consume` on the registry. If the message\n * was approved, the value is updated to `false`, and we return the success flag. For more information on the\n * registry, see `main.nr` in `auth_registry_contract`.\n *\n * Person          Contract              Contract            Contract               Contract\n * Alice          Alice Account          Registry             Token                   DeFi\n *   |                  |                    |                   |                      |\n *   | Registry.set_authorized(..., true)    |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | set_authorized(..., true)              |                      |\n *   |                  |------------------->|                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |         set authorized to true         |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   | Defi.deposit(Token, 1000)             |                   |                      |\n *   |----------------->|                    |                   |                      |\n *   |                  | deposit(Token, 1000)                   |                      |\n *   |                  |-------------------------------------------------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |              transfer(Alice, Defi, 1000) |\n *   |                  |                    |                   |<---------------------|\n *   |                  |                    |                   |                      |\n *   |                  |                    | Check if Defi may call transfer(Alice, Defi, 1000)\n *   |                  |                    |<------------------|                      |\n *   |                  |                    |                   |                      |\n *   |                  |          throw if invalid AuthWit      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |           set authorized to false      |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    | AuthWit validity  |                      |\n *   |                  |                    |------------------>|                      |\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | transfer(Alice, Defi, 1000)\n *   |                  |                    |                   |<-------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   | success              |\n *   |                  |                    |                   |--------------------->|\n *   |                  |                    |                   |                      |\n *   |                  |                    |                   |     deposit(Token, 1000)\n *   |                  |                    |                   |                      |\n *\n *\n * --- FAQ ---\n * Q:   Why are we using a success flag of `poseidon2_hash_bytes(\"IS_VALID()\")` instead of just returning a boolean?\n * A:   We want to make sure that we don't accidentally return `true` if there is a collision in the function selector.\n *      By returning a hash of `IS_VALID()`, it becomes very unlikely that there is both a collision and we return\n *      a success flag.\n *\n * Q:   Why are we using static calls?\n * A:   We are using static calls to ensure that the account contract cannot re-enter. If it was a normal call, it\n *      could make a new call and do a re-entry attack. Using a static ensures that it cannot update any state.\n *\n * Q:   Would it not be cheaper to use a nullifier instead of updating state in public?\n * A:   At a quick glance, a public state update + nullifier is 96 bytes, but two state updates are 128, so it would be\n *      cheaper to use a nullifier, if this is the way it would always be done. However, if both the approval and the\n *      consumption is done in the same transaction, then we will be able to squash the updates (only final tx state diff is posted to DA), and now it is cheaper.\n *\n * Q:   Why is the chain id and the version part of the message hash?\n * A:   The chain id and the version is part of the message hash to ensure that the message is only valid on a specific\n *      chain to avoid a case where the same message could be used across multiple chains.\n */\n\nglobal IS_VALID_SELECTOR: Field = 0x47dacd73; // 4 last bytes of poseidon2_hash_bytes(\"IS_VALID()\")\n\n/**\n * Assert that `on_behalf_of` has authorized the current call with a valid authentication witness\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit\npub fn assert_current_call_valid_authwit(context: &mut PrivateContext, on_behalf_of: AztecAddress) {\n    let inner_hash = compute_inner_authwit_hash([\n        context.msg_sender().to_field(),\n        context.selector().to_field(),\n        context.args_hash,\n    ]);\n    assert_inner_hash_valid_authwit(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit\n\n/**\n * Assert that a specific `inner_hash` is valid for the `on_behalf_of` address\n *\n * Used as an internal function for `assert_current_call_valid_authwit` and can be used as a standalone function when\n * the `inner_hash` is from a different source, e.g., say a block of text etc.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n * @param inner_hash The hash of the message to authorize\n */\npub fn assert_inner_hash_valid_authwit(\n    context: &mut PrivateContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    // We perform a static call here and not a standard one to ensure that the account contract cannot re-enter.\n    let result: Field = context\n        .static_call_private_function(\n            on_behalf_of,\n            comptime { FunctionSelector::from_signature(\"verify_private_authwit(Field)\") },\n            [inner_hash],\n        )\n        .unpack_into();\n    assert(result == IS_VALID_SELECTOR, \"Message not authorized by account\");\n    // Compute the nullifier, similar computation to the outer hash, but without the chain_id and version.\n    // Those should already be handled in the verification, so we just need something to nullify, that allows the same inner_hash for multiple actors.\n    let nullifier = compute_authwit_nullifier(on_behalf_of, inner_hash);\n    context.push_nullifier(nullifier);\n}\n\n/**\n * Assert that `on_behalf_of` has authorized the current call in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the current call\n */\n// docs:start:assert_current_call_valid_authwit_public\npub unconstrained fn assert_current_call_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n) {\n    let inner_hash = compute_inner_authwit_hash([\n        (*context).msg_sender().to_field(),\n        (*context).selector().to_field(),\n        (*context).get_args_hash(),\n    ]);\n    assert_inner_hash_valid_authwit_public(context, on_behalf_of, inner_hash);\n}\n// docs:end:assert_current_call_valid_authwit_public\n\n/**\n * Assert that `on_behalf_of` has authorized a specific `inner_hash` in the authentication registry\n *\n * Compute the `inner_hash` using the `msg_sender`, `selector` and `args_hash` and then make a call out to the\n * `on_behalf_of` contract to verify that the `inner_hash` is valid.\n *\n * Note that the authentication registry will take the `msg_sender` into account as the consumer, so this will only\n * work if the `msg_sender` is the same as the `consumer` when the `message_hash` was inserted into the registry.\n *\n * @param on_behalf_of The address that has allegedly authorized the `inner_hash`\n */\npub unconstrained fn assert_inner_hash_valid_authwit_public(\n    context: &mut PublicContext,\n    on_behalf_of: AztecAddress,\n    inner_hash: Field,\n) {\n    let results: [Field] = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"consume((Field),Field)\") },\n        [on_behalf_of.to_field(), inner_hash].as_slice(),\n        GasOpts::default(),\n    );\n    assert(results.len() == 1, \"Invalid response from registry\");\n    assert(results[0] == IS_VALID_SELECTOR, \"Message not authorized by account\");\n}\n\n/**\n * Compute the `message_hash` from a function call to be used by an authentication witness\n *\n * Useful for when you need a non-account contract to approve during execution. For example if you need a contract\n * to make a call to nested contract, e.g., contract A wants to exit token T to L1 using bridge B, so it needs to allow\n * B to transfer T on its behalf.\n *\n * @param caller The address of the contract that is calling the function, in the example above, this would be B\n * @param consumer The address of the contract that is consuming the message, in the example above, this would be T\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param selector The function selector of the function that is being called\n * @param args The arguments of the function that is being called\n */\n// docs:start:compute_authwit_message_hash_from_call\npub fn compute_authwit_message_hash_from_call<let N: u32>(\n    caller: AztecAddress,\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    selector: FunctionSelector,\n    args: [Field; N],\n) -> Field {\n    let args_hash = hash_args_array(args);\n    let inner_hash =\n        compute_inner_authwit_hash([caller.to_field(), selector.to_field(), args_hash]);\n    compute_authwit_message_hash(consumer, chain_id, version, inner_hash)\n}\n// docs:end:compute_authwit_message_hash_from_call\n\n/**\n * Computes the `inner_hash` of the authentication witness\n *\n * This is used internally, but also useful in cases where you want to compute the `inner_hash` for a specific message\n * that is not necessarily a call, but just some \"bytes\" or text.\n *\n * @param args The arguments to hash\n */\npub fn compute_inner_authwit_hash<let N: u32>(args: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(args, GENERATOR_INDEX__AUTHWIT_INNER)\n}\n\n/**\n * Computes the `authwit_nullifier` for a specific `on_behalf_of` and `inner_hash`\n *\n * Using the `on_behalf_of` and the `inner_hash` to ensure that the nullifier is siloed for a specific `on_behalf_of`.\n *\n * @param on_behalf_of The address that has authorized the `inner_hash`\n * @param inner_hash The hash of the message to authorize\n */\npub fn compute_authwit_nullifier(on_behalf_of: AztecAddress, inner_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [on_behalf_of.to_field(), inner_hash],\n        GENERATOR_INDEX__AUTHWIT_NULLIFIER,\n    )\n}\n\n/**\n * Computes the `message_hash` for the authentication witness\n *\n * @param consumer The address of the contract that is consuming the message\n * @param chain_id The chain id of the chain that the message is being consumed on\n * @param version The version of the chain that the message is being consumed on\n * @param inner_hash The hash of the \"inner\" message that is being consumed\n */\npub fn compute_authwit_message_hash(\n    consumer: AztecAddress,\n    chain_id: Field,\n    version: Field,\n    inner_hash: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [consumer.to_field(), chain_id, version, inner_hash],\n        GENERATOR_INDEX__AUTHWIT_OUTER,\n    )\n}\n\n/**\n * Helper function to set the authorization status of a message hash\n *\n * Wraps a public call to the authentication registry to set the authorization status of a `message_hash`\n *\n * @param message_hash The hash of the message to authorize\n * @param authorize True if the message should be authorized, false if it should be revoked\n */\npub unconstrained fn set_authorized(\n    context: &mut PublicContext,\n    message_hash: Field,\n    authorize: bool,\n) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_authorized(Field,bool)\") },\n        [message_hash, authorize as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n\n/**\n * Helper function to reject all authwits\n *\n * Wraps a public call to the authentication registry to set the `reject_all` flag\n *\n * @param reject True if all authwits should be rejected, false otherwise\n */\npub unconstrained fn set_reject_all(context: &mut PublicContext, reject: bool) {\n    let res = context.call_public_function(\n        CANONICAL_AUTH_REGISTRY_ADDRESS,\n        comptime { FunctionSelector::from_signature(\"set_reject_all(bool)\") },\n        [context.this_address().to_field(), reject as Field].as_slice(),\n        GasOpts::default(),\n    );\n    assert(res.len() == 0);\n}\n"
     },
-    "430": {
-      "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/main.nr",
-      "source": "mod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrAccount {\n    use dep::authwit::{\n        account::AccountActions,\n        auth::{compute_authwit_message_hash, compute_authwit_nullifier},\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n    use dep::aztec::encrypted_logs::encrypted_note_emission::encode_and_encrypt_note;\n    use dep::aztec::hash::compute_siloed_nullifier;\n    use dep::aztec::macros::{\n        functions::{initializer, noinitcheck, private, view},\n        storage::storage,\n    };\n    use dep::aztec::oracle::get_nullifier_membership_witness::get_low_nullifier_membership_witness;\n    use dep::aztec::prelude::{AztecAddress, PrivateContext, PrivateImmutable};\n\n    use crate::public_key_note::PublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        signing_public_key: PrivateImmutable<PublicKeyNote, Context>,\n    }\n\n    // Constructs the contract\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: Field, signing_pub_key_y: Field) {\n        let this = context.this_address();\n        let mut pub_key_note = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n        storage.signing_public_key.initialize(&mut pub_key_note).emit(encode_and_encrypt_note(\n            &mut context,\n            this,\n            this,\n        ));\n    }\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts file\n    #[private]\n    #[noinitcheck]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[noinitcheck]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        // docs:start:is_valid_impl\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.signing_public_key.get_note();\n        // Load auth witness\n        let witness: [Field; 64] = unsafe { get_auth_witness(outer_hash) };\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n\n        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        // Verify signature of the payload bytes\n        schnorr::verify_signature(pub_key, signature, outer_hash.to_be_bytes::<32>())\n        // docs:end:is_valid_impl\n    }\n\n    /**\n    * @notice Helper function to check validity of private authwitnesses\n    * @param consumer The address of the consumer of the message\n    * @param message_hash The message hash of the message to check the validity\n    * @return True if the message_hash can be consumed, false otherwise\n    */\n    unconstrained fn lookup_validity(consumer: AztecAddress, inner_hash: Field) -> pub bool {\n        let public_key = storage.signing_public_key.view_note();\n\n        let message_hash = compute_authwit_message_hash(\n            consumer,\n            context.chain_id(),\n            context.version(),\n            inner_hash,\n        );\n\n        let witness: [Field; 64] = get_auth_witness(message_hash);\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        let valid_in_private =\n            schnorr::verify_signature(pub_key, signature, message_hash.to_be_bytes::<32>());\n\n        // Compute the nullifier and check if it is spent\n        // This will BLINDLY TRUST the oracle, but the oracle is us, and\n        // it is not as part of execution of the contract, so we are good.\n        let nullifier = compute_authwit_nullifier(context.this_address(), inner_hash);\n        let siloed_nullifier = compute_siloed_nullifier(consumer, nullifier);\n        let lower_wit =\n            get_low_nullifier_membership_witness(context.block_number(), siloed_nullifier);\n        let is_spent = lower_wit.leaf_preimage.nullifier == siloed_nullifier;\n\n        !is_spent & valid_in_private\n    }\n}\n"
-    },
-    "431": {
+    "435": {
       "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/public_key_note.nr",
       "source": "use dep::aztec::{\n    keys::getters::{get_nsk_app, get_public_keys},\n    macros::notes::note,\n    note::utils::compute_note_hash_for_nullify,\n    protocol_types::{\n        address::AztecAddress, constants::GENERATOR_INDEX__NOTE_NULLIFIER,\n        hash::poseidon2_hash_with_separator,\n    },\n};\nuse dep::aztec::prelude::{NoteHeader, NullifiableNote, PrivateContext};\n\n// Stores a public key composed of two fields\n// TODO: Do we need to include a nonce, in case we want to read/nullify/recreate with the same pubkey value?\n#[note]\npub struct PublicKeyNote {\n    x: Field,\n    y: Field,\n    owner: AztecAddress,\n}\n\nimpl NullifiableNote for PublicKeyNote {\n    fn compute_nullifier(\n        self,\n        context: &mut PrivateContext,\n        note_hash_for_nullify: Field,\n    ) -> Field {\n        let owner_npk_m_hash: Field = get_public_keys(self.owner).npk_m.hash();\n        let secret = context.request_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [note_hash_for_nullify, secret],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n        )\n    }\n\n    unconstrained fn compute_nullifier_without_context(self) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_nullify(self);\n        let owner_npk_m_hash: Field = get_public_keys(self.owner).npk_m.hash();\n        let secret = get_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [note_hash_for_nullify, secret],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field,\n        )\n    }\n}\n\nimpl PublicKeyNote {\n    pub fn new(x: Field, y: Field, owner: AztecAddress) -> Self {\n        PublicKeyNote { x, y, owner, header: NoteHeader::empty() }\n    }\n}\n"
     },
-    "432": {
+    "436": {
+      "path": "/usr/src/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/main.nr",
+      "source": "mod public_key_note;\n\n// Account contract that uses Schnorr signatures for authentication.\n// The signing key is stored in an immutable private note and should be different from the encryption/nullifying key.\nuse dep::aztec::macros::aztec;\n\n#[aztec]\ncontract SchnorrAccount {\n    use dep::authwit::{\n        account::AccountActions,\n        auth::{compute_authwit_message_hash, compute_authwit_nullifier},\n        auth_witness::get_auth_witness,\n        entrypoint::{app::AppPayload, fee::FeePayload},\n    };\n    use dep::aztec::encrypted_logs::encrypted_note_emission::encode_and_encrypt_note;\n    use dep::aztec::hash::compute_siloed_nullifier;\n    use dep::aztec::macros::{\n        functions::{initializer, noinitcheck, private, view},\n        storage::storage,\n    };\n    use dep::aztec::oracle::get_nullifier_membership_witness::get_low_nullifier_membership_witness;\n    use dep::aztec::prelude::{AztecAddress, PrivateContext, PrivateImmutable};\n\n    use crate::public_key_note::PublicKeyNote;\n\n    #[storage]\n    struct Storage<Context> {\n        signing_public_key: PrivateImmutable<PublicKeyNote, Context>,\n    }\n\n    // Constructs the contract\n    #[private]\n    #[initializer]\n    fn constructor(signing_pub_key_x: Field, signing_pub_key_y: Field) {\n        let this = context.this_address();\n        let mut pub_key_note = PublicKeyNote::new(signing_pub_key_x, signing_pub_key_y, this);\n        storage.signing_public_key.initialize(&mut pub_key_note).emit(encode_and_encrypt_note(\n            &mut context,\n            this,\n            this,\n        ));\n    }\n\n    // Note: If you globally change the entrypoint signature don't forget to update account_entrypoint.ts file\n    #[private]\n    #[noinitcheck]\n    fn entrypoint(app_payload: AppPayload, fee_payload: FeePayload, cancellable: bool) {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.entrypoint(app_payload, fee_payload, cancellable);\n    }\n\n    #[private]\n    #[noinitcheck]\n    #[view]\n    fn verify_private_authwit(inner_hash: Field) -> Field {\n        let actions = AccountActions::init(&mut context, is_valid_impl);\n        actions.verify_private_authwit(inner_hash)\n    }\n\n    #[contract_library_method]\n    fn is_valid_impl(context: &mut PrivateContext, outer_hash: Field) -> bool {\n        // docs:start:is_valid_impl\n        // Load public key from storage\n        let storage = Storage::init(context);\n        let public_key = storage.signing_public_key.get_note();\n        // Load auth witness\n        let witness: [Field; 64] = unsafe { get_auth_witness(outer_hash) };\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n\n        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        // Verify signature of the payload bytes\n        schnorr::verify_signature(pub_key, signature, outer_hash.to_be_bytes::<32>())\n        // docs:end:is_valid_impl\n    }\n\n    /**\n    * @notice Helper function to check validity of private authwitnesses\n    * @param consumer The address of the consumer of the message\n    * @param message_hash The message hash of the message to check the validity\n    * @return True if the message_hash can be consumed, false otherwise\n    */\n    unconstrained fn lookup_validity(consumer: AztecAddress, inner_hash: Field) -> pub bool {\n        let public_key = storage.signing_public_key.view_note();\n\n        let message_hash = compute_authwit_message_hash(\n            consumer,\n            context.chain_id(),\n            context.version(),\n            inner_hash,\n        );\n\n        let witness: [Field; 64] = get_auth_witness(message_hash);\n        let mut signature: [u8; 64] = [0; 64];\n        for i in 0..64 {\n            signature[i] = witness[i] as u8;\n        }\n        let pub_key = std::embedded_curve_ops::EmbeddedCurvePoint {\n            x: public_key.x,\n            y: public_key.y,\n            is_infinite: false,\n        };\n        let valid_in_private =\n            schnorr::verify_signature(pub_key, signature, message_hash.to_be_bytes::<32>());\n\n        // Compute the nullifier and check if it is spent\n        // This will BLINDLY TRUST the oracle, but the oracle is us, and\n        // it is not as part of execution of the contract, so we are good.\n        let nullifier = compute_authwit_nullifier(context.this_address(), inner_hash);\n        let siloed_nullifier = compute_siloed_nullifier(consumer, nullifier);\n        let lower_wit =\n            get_low_nullifier_membership_witness(context.block_number(), siloed_nullifier);\n        let is_spent = lower_wit.leaf_preimage.nullifier == siloed_nullifier;\n\n        !is_spent & valid_in_private\n    }\n}\n"
+    },
+    "437": {
       "path": "/root/nargo/github.com/noir-lang/schnorr/v0.1.1/src/lib.nr",
       "source": "use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};\nuse std::hash::{blake2s, pedersen_hash};\n\npub fn verify_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) -> bool {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n    // pub_key is on Grumpkin curve\n    let mut is_ok = (public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17)\n        & (!public_key.is_infinite);\n\n    if ((sig_s.lo != 0) | (sig_s.hi != 0)) & ((sig_e.lo != 0) | (sig_e.hi != 0)) {\n        let (r_is_infinite, result) =\n            calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n        is_ok &= !r_is_infinite;\n        for i in 0..32 {\n            is_ok &= result[i] == signature[32 + i];\n        }\n    } else {\n        is_ok = false;\n    }\n    is_ok\n}\n\npub fn assert_valid_signature<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    signature: [u8; 64],\n    message: [u8; N],\n) {\n    //scalar lo/hi from bytes\n    let sig_s = scalar_from_bytes(signature, 0);\n    let sig_e = scalar_from_bytes(signature, 32);\n\n    // assert pub_key is on Grumpkin curve\n    assert(public_key.y * public_key.y == public_key.x * public_key.x * public_key.x - 17);\n    assert(public_key.is_infinite == false);\n    // assert signature is not null\n    assert((sig_s.lo != 0) | (sig_s.hi != 0));\n    assert((sig_e.lo != 0) | (sig_e.hi != 0));\n\n    let (r_is_infinite, result) = calculate_signature_challenge(public_key, sig_s, sig_e, message);\n\n    assert(!r_is_infinite);\n    for i in 0..32 {\n        assert(result[i] == signature[32 + i]);\n    }\n}\n\nfn calculate_signature_challenge<let N: u32>(\n    public_key: EmbeddedCurvePoint,\n    sig_s: EmbeddedCurveScalar,\n    sig_e: EmbeddedCurveScalar,\n    message: [u8; N],\n) -> (bool, [u8; 32]) {\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    let r = multi_scalar_mul([g1, public_key], [sig_s, sig_e]);\n    // compare the _hashes_ rather than field elements modulo r\n    let pedersen_hash = pedersen_hash([r.x, public_key.x, public_key.y]);\n    let pde: [u8; 32] = pedersen_hash.to_be_bytes();\n\n    let mut hash_input = [0; N + 32];\n    for i in 0..32 {\n        hash_input[i] = pde[i];\n    }\n    for i in 0..N {\n        hash_input[32 + i] = message[i];\n    }\n\n    let result = blake2s(hash_input);\n    (r.is_infinite, result)\n}\n\n//Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\nfn scalar_from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n    let mut v: Field = 1;\n    let mut lo: Field = 0;\n    let mut hi: Field = 0;\n    for i in 0..16 {\n        lo = lo + (bytes[offset + 31 - i] as Field) * v;\n        hi = hi + (bytes[offset + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    let sig_s = EmbeddedCurveScalar::new(lo, hi);\n    sig_s\n}\n\nmod test {\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    use super::verify_signature;\n\n    #[test]\n    fn test_zero_signature() {\n        let public_key: EmbeddedCurvePoint = EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860,\n            is_infinite: false,\n        };\n        let signature: [u8; 64] = [0; 64];\n        let message: [u8; _] = [2; 64]; // every message\n        let verified = verify_signature(public_key, signature, message);\n        assert(!verified);\n    }\n\n    #[test]\n    fn smoke_test() {\n        let message: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n        let pub_key_x: Field = 0x04b260954662e97f00cab9adb773a259097f7a274b83b113532bce27fa3fb96a;\n        let pub_key_y: Field = 0x2fd51571db6c08666b0edfbfbc57d432068bccd0110a39b166ab243da0037197;\n        let signature: [u8; 64] = [\n            1, 13, 119, 112, 212, 39, 233, 41, 84, 235, 255, 93, 245, 172, 186, 83, 157, 253, 76,\n            77, 33, 128, 178, 15, 214, 67, 105, 107, 177, 234, 77, 48, 27, 237, 155, 84, 39, 84,\n            247, 27, 22, 8, 176, 230, 24, 115, 145, 220, 254, 122, 135, 179, 171, 4, 214, 202, 64,\n            199, 19, 84, 239, 138, 124, 12,\n        ];\n\n        let pub_key = EmbeddedCurvePoint { x: pub_key_x, y: pub_key_y, is_infinite: false };\n        let valid_signature = verify_signature(pub_key, signature, message);\n        assert(valid_signature);\n        super::assert_valid_signature(pub_key, signature, message);\n    }\n\n}\n\nmod bench {\n    use super::{assert_valid_signature, verify_signature};\n    use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n    #[export]\n    pub fn bench_verify_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) -> bool {\n        verify_signature(public_key, signature, message)\n    }\n\n    #[export]\n    pub fn bench_assert_valid_signature(\n        public_key: EmbeddedCurvePoint,\n        signature: [u8; 64],\n        message: [u8; 32],\n    ) {\n        assert_valid_signature(public_key, signature, message)\n    }\n}\n"
     }