@aztec/accounts 0.70.0 → 0.72.1

package/artifacts/SchnorrAccount.json

@@ -1,15 +1,193 @@
 {
   "transpiled": true,
-  "noir_version": "1.0.0-beta.1+561b7ed4beb7b55c",
+  "noir_version": "1.0.0-beta.1+4ca7394b2efd7aef",
   "name": "SchnorrAccount",
   "functions": [
     {
-      "name": "verify_private_authwit",
+      "name": "process_log",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "16954218183513903507": {
+            "error_kind": "string",
+            "string": "Attempted to read past end of BoundedVec"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "6753155520859132764": {
+            "error_kind": "string",
+            "string": "Failed to deliver note"
+          },
+          "8270195893599566439": {
+            "error_kind": "string",
+            "string": "Invalid public keys hint for address"
+          },
+          "8861757336002045335": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              },
+              {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 32
+              },
+              {
+                "kind": "field"
+              }
+            ],
+            "length": 99
+          },
+          "9862881900111276825": {
+            "error_kind": "fmtstring",
+            "item_types": [
+              {
+                "kind": "field"
+              }
+            ],
+            "length": 35
+          }
+        },
+        "parameters": [
+          {
+            "name": "log_plaintext",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 18,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "tx_hash",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "unique_note_hashes_in_tx",
+            "type": {
+              "fields": [
+                {
+                  "name": "storage",
+                  "type": {
+                    "kind": "array",
+                    "length": 64,
+                    "type": {
+                      "kind": "field"
+                    }
+                  }
+                },
+                {
+                  "name": "len",
+                  "type": {
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "std::collections::bounded_vec::BoundedVec"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "first_nullifier_in_tx",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "recipient",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": null
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "process_log"
+      ]
+    },
+    {
+      "name": "sync_notes",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          }
+        },
+        "parameters": [],
+        "return_type": null
+      },
+      "bytecode": "H4sIAAAAAAAA/9VTvQ6CMBBu+YmCMqiJbia+QREMjCbuvkMDMuqAixuPLjXX9FKbMLQ18Uuaa+Hy/ZSDEgUKNSIWkCQHqAnUAL0Px3WGM7NDnmi6LvlrVhaJIZ9D/x9+6sm/gOT3dP9sBjyXQfHjLFJ3Pq4UzYSvzPKb+cy8mci5+kHOEcdM08aghmehoYci3zvYZ4Y+iQVR/3Q0uM9V1YxJvRD4Y/LtHevHWv8WzqnmX9TIwmdX8bwreMdPvG3Lhq81foEA3dM/z8Ie9lOzgDMuiZqN/nVvro/nrScTECRvfuFT84YGAAA=",
+      "debug_symbols": "ndLNCoQgFAXgd7nrFl3771ViCCsLQTTMBobo3UcjZpqhjW4uHvG7bs4GA+vWqeVyVAvUzQZC9dRwJW3a9gg6zYXgU3u9htgNxOP9MlPp4mKoNlCTFCNgcnCnyvqRCwZ1TvZHBEi8ReItUm+R+Qpy+wfGcVmcBmPE9KMwzQ6WhbE8jBVhrAxiCd4zLPIvq7Jfttv4pJrTTrCzbuMq+0v7zGtmf0WcterZsGrmKnlpo50NFhEhdq1d/QY=",
+      "brillig_names": [
+        "sync_notes"
+      ]
+    },
+    {
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
         "private",
-        "noinitcheck",
-        "view"
+        "noinitcheck"
       ],
       "abi": {
         "error_types": {
@@ -30,18 +208,14 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
-            "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
-          },
-          "4939791462094160055": {
-            "error_kind": "string",
-            "string": "Message not authorized by account"
-          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
+          "5727012404371710682": {
+            "error_kind": "string",
+            "string": "push out of bounds"
+          },
           "6869395374906889440": {
             "error_kind": "string",
             "string": "Mismatch note header contract address."
@@ -530,9 +704,173 @@
             "visibility": "private"
           },
           {
-            "name": "inner_hash",
+            "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": "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"
             },
             "visibility": "private"
           }
@@ -1642,18 +1980,22 @@
           "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",
-        "store_in_execution_cache_oracle_wrapper",
+        "enqueue_public_function_call_internal",
+        "call_private_function_internal",
+        "debug_log_oracle_wrapper",
+        "notify_set_min_revertible_side_effect_counter_oracle_wrapper",
+        "notify_created_nullifier_oracle_wrapper",
         "directive_invert",
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "name": "lookup_validity",
@@ -1661,108 +2003,42 @@
       "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": {
+          "12099279057757775880": {
             "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
+            "string": "DST_LEN too large for offset"
           },
           "16761564377371454734": {
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
+          "16954218183513903507": {
+            "error_kind": "string",
+            "string": "Attempted to read past end of BoundedVec"
+          },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
+          "2920182694213909827": {
+            "error_kind": "string",
+            "string": "attempt to subtract with overflow"
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "8270195893599566439": {
+          "5727012404371710682": {
             "error_kind": "string",
-            "string": "Invalid public keys hint for address"
+            "string": "push out of bounds"
+          },
+          "7233212735005103307": {
+            "error_kind": "string",
+            "string": "attempt to multiply with overflow"
           }
         },
         "parameters": [
           {
-            "name": "contract_address",
+            "name": "consumer",
             "type": {
               "fields": [
                 {
@@ -1778,68 +2054,33 @@
             "visibility": "private"
           },
           {
-            "name": "nonce",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "storage_slot",
-            "type": {
-              "kind": "field"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "note_type_id",
+            "name": "inner_hash",
             "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"
-            }
+            "kind": "boolean"
           },
           "visibility": "public"
         }
       },
-      "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"
+        "lookup_validity"
       ]
     },
     {
-      "name": "entrypoint",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
         "private",
-        "noinitcheck"
+        "noinitcheck",
+        "view"
       ],
       "abi": {
         "error_types": {
@@ -1860,13 +2101,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",
@@ -2316,213 +2561,49 @@
                                 "fields": [
                                   {
                                     "name": "fee_per_da_gas",
-                                    "type": {
-                                      "kind": "field"
-                                    }
-                                  },
-                                  {
-                                    "name": "fee_per_l2_gas",
-                                    "type": {
-                                      "kind": "field"
-                                    }
-                                  }
-                                ],
-                                "kind": "struct",
-                                "path": "authwit::aztec::protocol_types::abis::gas_fees::GasFees"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "authwit::aztec::protocol_types::abis::gas_settings::GasSettings"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
-                  }
-                },
-                {
-                  "name": "start_side_effect_counter",
-                  "type": {
-                    "kind": "integer",
-                    "sign": "unsigned",
-                    "width": 32
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "app_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 4,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "authwit::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
-                  }
-                }
-              ],
-              "kind": "struct",
-              "path": "authwit::entrypoint::app::AppPayload"
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "fee_payload",
-            "type": {
-              "fields": [
-                {
-                  "name": "function_calls",
-                  "type": {
-                    "kind": "array",
-                    "length": 2,
-                    "type": {
-                      "fields": [
-                        {
-                          "name": "args_hash",
-                          "type": {
-                            "kind": "field"
-                          }
-                        },
-                        {
-                          "name": "function_selector",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "integer",
-                                  "sign": "unsigned",
-                                  "width": 32
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::abis::function_selector::FunctionSelector"
-                          }
-                        },
-                        {
-                          "name": "target_address",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
-                          }
-                        },
-                        {
-                          "name": "is_public",
-                          "type": {
-                            "kind": "boolean"
-                          }
-                        },
-                        {
-                          "name": "is_static",
-                          "type": {
-                            "kind": "boolean"
-                          }
+                                    "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::entrypoint::function_call::FunctionCall"
-                    }
-                  }
-                },
-                {
-                  "name": "nonce",
-                  "type": {
-                    "kind": "field"
+                      }
+                    ],
+                    "kind": "struct",
+                    "path": "authwit::aztec::protocol_types::transaction::tx_context::TxContext"
                   }
                 },
                 {
-                  "name": "is_fee_payer",
+                  "name": "start_side_effect_counter",
                   "type": {
-                    "kind": "boolean"
+                    "kind": "integer",
+                    "sign": "unsigned",
+                    "width": 32
                   }
                 }
               ],
               "kind": "struct",
-              "path": "authwit::entrypoint::fee::FeePayload"
+              "path": "aztec::context::inputs::private_context_inputs::PrivateContextInputs"
             },
             "visibility": "private"
           },
           {
-            "name": "cancellable",
+            "name": "inner_hash",
             "type": {
-              "kind": "boolean"
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -3632,42 +3713,18 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "7V3tjhzHrX0X/daPLpL1lVe5CALHcQIBhh3YzgUuAr/77ZU0vSstXbRqZnoOt/gnyFpdXZwzbJLNqXP433f/+OHv//nX3z789M+ff333l//577sff/7+u98+/PzT/td/3yX6+N9+/fd3Pz39+etv3/3y27u/pNK39+9++Okf+/+t2/b7+3f//PDjD+/+Uuj3968uJir188VErR8Xd9Yu7tI+X8wbpfHFqQhfrt7/f6bjcipJu3micrEkSX6+ujbt7lz4cnNJ2xdX//X9u8SBzB8gI4HMHyCTA5k/QKZcjYxsnT5fLInacXHbPm5Q771B+8YNntZ0bQ3nC65CL4AqqjccJhFveXxx4nS5ODEn4+It9cvFW2nji1vpl4tb5WI4ThM6rpZaTTeT4yOmSsbT0YkOh+/Pty6iXbzVcjGEtr69uDw/fTu0xbcD/O2k+HaAvx269tupB4ZUmQ3Aay1HlO05vh3r2+H4doC/HYlvB/jbUWv4b7KHU77U8Jw6G/ZIvlSQJC0bd97Sc8Gf5bg4Za3i52fIWcqzUyXij5+0LPNJ6xv6pOW4Oqf8xSfV3vme38rqC1e/4NJWxaW+wKW3V7j0t4NLzvnApZu4bOlIFhu/xKUrV+cj7GZ67lQU1Qzqhxn84sZ702LHm7fA+8Z4y8ZHQMz5a7xT4H2qf1Pgfap/c+B9qn9L4H2qf7+hdxQQvOvxswu39AxHqh/xfkNvSt+G9945veBNQl/g/YTLG3qvuikub+i96qa49Oh83bTz5dRLRI4vJm/FiOLEz9+5cP4Cvt2nZAufCp+6sU+l8KnwqRv7VPxiGj71dLqgHVjnVC2fSvn4zumLYwmffCp+5w2furVPydt5dylbulxduBgo9n5Y3Xt9vnfbNKup9WcU+6vTgvKGOjQPRPHsvkvd2nM4LC/v/GTN2d2Oxgc4LeevrWlQ1nQka/IGZU2CsoagrGEoawTKmgxlTYGyBioWZ6hYnKFicYGKxQUqFheoWFygYnGBisUFKhYXqFhcoGJxgYrFBSoWV6hYXKFicYWKxRUqFleoWFyhYnGFisUVKhZXqFhcoWJxg4rFDSoWN6hY3KBicYOKxQ0qFjeoWNygYnGDisUNKhZ3qFjcoWJxh4rFHSoWd6hY3KFicYeKxR0qFneoWNyhYnHaoIJx2qCicdqgwnHaoOJx2qACctqgInLaoEJy2qBictqggnLasKJyworKCSsqJ6yonLCicsKKygkrKiesqJywonLCisoJKyoTVlQmrKhMWFGZsKIyYUVlworKhBWVCSsqE1ZUJqyozFhRmbGiMmNFZcaKyowVlRkrKjNWVGasqMxYUZmxorJgRWXBisqCFZUFKyoLVlQWrKgsWFEZi6eXsIh6CYupl7CoegmLq5ewyHoJi62XsOh6CYuvl7AIewmLsZewKHsJi7OXsEh7CYu1l7BoewmLt5ewiHsJi7mXsKh7CYu7l7DIewmLvZew6HsJi7+XsAh8CYvBl7AofAmLw5ewSHwJi8WXsGh8CYvHl7CIfAmLyZewqHwJi8uXsMh8CYvNl7DofAmLz5ewCH0Ji9GXsCh9CYvTl7BIfQmL1ZewaH0Ji9eXsIh9CYvZl7CofQmL20dY3D7C4vYRFrePsLh9tEFFZcLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbR1jcPsLi9hEWt4+wuH2Exe0jLG4fYXH7CIvbx1jcPsbi9jEWt4+xuH28QUVlxuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9vHWNw+xuL2MRa3j7G4fYzF7WMsbh9jcfsYi9snWNw+weL2CRa3T7C4fbJBRWXB4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL2ydY3D7B4vYJFrdPsLh9gsXtEyxun2Bx+wSL25exuH0Zi9uXsbh9GYvblzeoqJyxuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fRmL25exuH0Zi9uXsbh9GYvbl7G4fQWL21ewuH0Fi9tXsLh9ZYOKygWL21ewuH0Fi9tXsLh9BYvbV7C4fQWL21ewuH0Fi9tXsLh9BYvbV7C4fQWL21ewuH0Fi9tXsLh9BYvbV7C4feVsbh8n2Y6Li3FnoePOQvX5zqkrF2fZyueLs5C8vPjjB5VVPmhe5YOWVT5oXeWDtlU+aF/kg57NKH3cB02rfFBa5YOuUhmdzdx93AddpTLiVSojXqUy4lUqI16lMpJVKiNZpTKSVSojWaUyOps9/7gPukplJKtURrJKZSSrVEaySmWUV6mM8iqVUV6lMsqrVEZnK1g87oOuUhnlVSqjDF0ZlU0uH7TQ9sp26GLHsB26fhnbXqBLkj1IHbbX17ZDVxmG7dCFg2E7dC1g2C6ObYfO2EacgU7Chu2O82rBzqtjf8fOq0Pbq+O8Wh3n1eo4r1bHefVsMZub2u44r1bHebU6zqvV8ftqdfy+2hzn1eY4rzbHebU5zqtnyxHd1HbsvDq2HTuvjm3Hzqtj2x2/rzbHebVj59Wx7dh5dWw7dl4d246dV8e2O86r3XFe7Y7zanecV7vjvNr99oHr5vd9tW5+31fr5vd9tW5+82rdsPPq2Ha/feC6+e0D181vH7hufvNq3Rzn1eQ4rybHeTU5zqvJbx+4ni3qdlPb/b6v1uT3fbUmx3k1+f19tSa/feBKfvvAlfz2gSs5zqvYSnuG7Y7zKrYenmG747yKrVpn2O74fRVbW25sO7ZcnGG747yKLepm2O64D4wtvWbY7rgPjC2QZsQZx3kVW8bMsN1xXsUWGzNsd9wHxpYEM2x3/L6KLdxl2O44r2LLaxm2O+4DY4tgGbY77gNjS1WN4wy2+pRhu+O8iq0RZdjuOK9iKzkZtjt+XwXXWxrb7vh91bHeUgXXWxrb7rgPDK63NLbdcR/Ysd5SBddbGtvuOK+C6y2NbXecVx3rLVXHekvVsd5Sday3VMH1loZ5FVxvaWy74z6wY72l6lhvqYLrLY3jjOO86lhvqTrWW6qO9ZaqY72l6lhvqTrWW6qO9ZYquN7SMK+C6y2NbXfcB3ast1Qd6y1VcL2lYZwB11sa2+44rzrWW6qO9ZaqY72l6lhvqTrWW2qO9ZYauN7SKK82cL2lse1++8Btw86rY9v99oEbuN7SOM74zavNsd5Sc6y31BzrLTXHekvNsd5Sc6y31BzrLTVwvaVhXgXXWxrb7rcP3BzrLTXHeksNXG9pGGfA9ZbGtjvOq471lppjvaXmWG+pOdZbao71lppjvaUGrrc0zKvgektj2x33gR3rLTXHeksNXG9pGGfA9ZbGtjvOq471lppjvaXmWG+pOdZbao71lppjvaUGrrc0zKvgektj2x33gR3rLTXHeksNXG9pHGcc51XHekvNsd5Sc6y31BzrLTXHekvNsd5Sc6y31MD1loZ5FVxvaWy74z6wY72l5lhvqYHrLQ3jDLje0th2x3nVsd5Sc6y31BzrLTXHekvNsd5Sc6y31MD1loZ5FVxvaWy74z6wY72l5lhvqYHrLY3jjOO86lhvqTnWW2qO9ZaaY72l5lhvqTnWW2qO9ZYauN7SMK+C6y2NbXfcB3ast9Qc6y01cL2lYZwB11sa2+44rzrWW2qO9ZaaY72l5lhvqTnWW2qO9ZYauN7SKK92cL2lse1++8Ddsd5Sd6y31De/ebWD6y2NbfebV7tjvaXuWG+pO9Zb6o71lrpjvaXuWG+pg+stDfMquN7S2Ha/feDuWG+pO9Zb6uB6S+M44zivOtZb6o71lrpjvaXuWG+pO9Zb6o71lrpjvaUOrrc0zKvgektj2x33gR3rLXXHeksdXG9pGGfA9ZbGtjvOq471lrpjvaXuWG+pO9Zb6o71lrpjvaUOrrc0zKvgektj2x33gR3rLXXHeksdXG9pHGcc51XHekvdsd5Sd6y31B3rLXXHekvdsd5Sd6y31MH1loZ5FVxvaWy74z6wY72l7lhvqYPrLQ3jDLje0th2x3nVsd5Sd6y31B3rLXXHekvdsd5Sd6y31MH1loZ5FVxvaWy74z6wY72l7lhvqYPrLQ3jDLje0th2x3nVsd5Sd6y31B3rLXXHekvdsd5Sd6y31MH1loZ5FVxvaWy74z6wY72l7lhvqYPrLY3jjOO86lhvqTvWW+qO9Za6Y72l7lhvqTvWW+qO9ZY6uN7SMK+C6y2NbffbB06bY8Gl3Xi/neDdeL+pdTfeb27djfebXHfj/WbX3Xi/6XU33m8/eDfe74vrbrzfN9e0OZZe2o33nGHBxZcM4/12hXfjsTOsYbzfvvBuvOcMC67AZBjvOcM61mBKm2MRpt14v93h3XjP77COdZh247EzrGG85wwLLsVkGO+3R7wb77dJvBvvuUsMLsc0jjbgekyG8Z4zrGNFpt14zxnWsSbTbrznd1jHqky78Z7fYcF1mcYZFlyYyTDec5fYsTTTbrznLjG4ONM42oCrMxnGe86wjvWZduM9Z1jHCk1pcyzRtBvv+R3WsUjTbrznDAsu02QY77lL7FioaTfec5cYXKrJiDae32HBxZoM4z2/w4LLNRnGe86wjgWbduM9Z1hwySbDeM8ZFly0yTDec4YFl20aRxtw3SbDeM/vsODKTYbx0Bm2tnQxvjZ+bfzZGXbrclxck2H8YXum5/syl8+2F2Tb83bY3hTbq2Pbm2Pbu1/bT9du+hbbc73cOPdNsT05tp0c286ObRfHtiPnVct25Lya+6UYK5sWI5HzqmU7cl61bEfOq4btHTqvGrZD51XDduS8WtJhu1aLdeS8atmOnFct25HzqmU7cl61bEfOq5btyHm1MF9sl6LYjpxXx7anDTmvWrYj51XLdui8atgOnVcN25Hzaq5HjJSm2I79vjq2HTmv1u3Sw64lf2H762tpOxrelDgZV3Mth80tvWjt18+wIKfsB8KCXA08EBbkQuNxsCTkGuaBsCCXRw+EBbnyuiMsrV+u5q7BglzUPRAWCVg0WJBL0QfCsmiVa8GyaJVrwbJolWvBsmiVa8BCi1a5Fix6lbulY4+Nn/sRlLQt6PgNjNm62CPgRAcYVLpxdZKjk5PyC8B3ND4BTtcDLtulSceScwA+BpzDw88FXMLDzwU8h4efC3gJDz8XcP0NiKld9uAaTmtg+GZel55j1e4Bm3G10GGzUP2CHfL64ixb+XxxFpKXF3/C8M28Wz0OQ34zL2IPxPDN/DbxQAzfzA8ZD8Twzfzq8UAMJTC8GsM383vKAzF8Mz++PBDDN/NLzQMxjPeU6zGM95SrMZR4T7kew3hPuR7DeE+5HsN4T7keQwkMr8Yw3lOuxzDeU67HMN5Trscw3lOuxzDeU67GMMd7yvUYxnvK9RjGe8r1GMZ7yvUYSmB4NYbxnnI9hvGecj2G8Z5yPYbxnnI9hvGecjWGJd5Trscw3lOuxzDeU67HcNH3lPFoiHT6IBonsCz6NmHBsugLwnjWRCqL1vwWLIuW8RYsi1bmBix10WLbgmXR+tmCZdGS2IIlqlytbjl9GJQTWKLKVWFZtco1YFm1yjVgiSpXzURR5WqwQE8LeyAsUeWqsESVq8KyapVrwCIBiwbLolVuzseM2ZzpNSxR5WrlHPSougfCsmqVa8CyapU7hgV6dt8DYYkqV0vQ0BMHHwhLVLkqLBKwaLCs2ss1YIkTCyoscWJBhSV6uSos0ctVYCHoSZoPaywQ9JDOhxX/BD3/84GwxIkFFRYJWDRY4sSCCktUuWqCjipXhSWqXBWWqHI1WN7OrNXbwhK9XBWW6OWqsEQvV4VFAhYNljixoDUW3s6s1ZsW/29n1uptYYkTCyoscWJBg+XtzFq9LSxR5WoJmqLKVWGJKleFRQIWDZY4saDCEr1cFZbo5aqwRC9XhSV6uRosqw6yNBoLq86mNIr/VcdNWrDEiQUVFglYNFjixIIKS1S5aoKOKleFJapcFZaocjVYVh2DaMESvVwVlujlqrBEL1eFRQIWDZY4saA1FlYd/GcU/6vO8rNgiRMLKixxYkGDZdUhehYsUeVqCXrVUXcWLFHlqrBIwKLBEicWVFiil6vCEr1cFZbo5aqwRC9Xg2XVEWxGY2HVqWpG8b/qoDQLljixoMIiAYsGS5xYUGGJKldN0FHlqrBElavCElWuBkvMPtNhiV6uCkv0clVYoperwiIBiwZLnFjQGgsx+0wt/mP2mQ5LnFhQYYkTCxosy84+M2CJKldL0DH7TIclqlwVFglYNFjixIIKS/RyVViil6vCEr1cFZbo5WqwrDr7zGgsLDv7bFz8Lzv7zIAlTiyosEjAosESJxZUWKLKVRN0VLkqLFHlqrBElavAwqvOPrNgiV6uCkv0clVYoperwiIBiwZLnFhQGgu87OyzYfHPy84+M2CJEwsqLHFiQYNl2dlnBixR5WoJOmaf6bBElavCIgGLBkucWFBhiV6uCkv0clVYoperwhK9XA2WVWefGY2FZWefjYv/ZWefGbDEiQUVFglYNFjixIIKS1S5aoKOKleFJapcFZaocjVYVp19ZsESvVwVlujlqrBEL1eFRQIWDZY4saA1FpadfTYu/pedfWbAEicWVFjixIIGy7KzzwxYosrVEnTMPtNhiSpXhUUCFg2WOLGgwhK9XBWW6OWqsEQvV4UlerkaLKvOPjMaC8vOPhsX/8vOPjNgiRMLKiwSsGiwxIkFFZaoctUEHVWuCktUuSosUeVqsKw6+8yCJXq5KizRy1VhiV6uCosELBoscWJBaywsO/tsXPwvO/vMgCVOLKiwxIkFDZZlZ58ZsESVqyXomH2mwxJVrgqLBCwaLHFiQYUlerkqLNHLVWGJXq4KS/RyNVhWnX1mNBaWnX02Lv6XnX1mwBInFlRYJGDRYIkTCyosUeWqCTqqXBWWqHJVWKLK1WBZdfaZBUv0clVYoperwhK9XBUWCVg0WOLEgtZYWHb22bj4X3b2mQFLnFhQYYkTCwossuzsMwOWqHKVBC0x+0yHJapcFRYJWDRY4sSCCkv0clVYoperwhK9XBWW6OVqsKw6+2zcWJBlZ5+Ni/9lZ58ZsMSJBRUWCVg0WOLEggpLVLlqgo4qV4UlqlwVlqhyNVhWnX1mwRK9XBWW6OWqsEQvV4VFAhYNljixoDUWlp19Ni7+l519ZsASJxZUWOLEggbLsrPPDFiiytUSdMw+02GJKleFRQIWDZY4saDCEr1cFZbo5aqwRC9XhSV6uRosq84+MxoLy84+Gxf/y84+M2CJEwsqLBKwaLDEiQUVlqhy1QQdVa4KS1S5KixR5WqwrDr7zIIlerkqLNHLVWGJXq4KiwQsGixxYkFrLCw7+2xc/C87+8yAJU4sqLDEiQUNlmVnnxmwRJWrJeiYfabDElWuCosELBoscWJBhSV6uSos0ctVYYlergpL9HI1WFadfWY0FpadfTYu/pedfWbAEicWVFgkYNFgiRMLKixR5aoJOqpcFZaoclVYosrVYFl19pkFS/RyVViil6vCEr1cFRYJWDRY4sSC1lhYdvbZuPhfdvaZAUucWFBhiRMLGizLzj4zYIkqV0vQMftMhyWqXBUWCVg0WOLEggpL9HJVWKKXq8ISvVwVlujlKrDkVWefjRsLednZZ8PiPy87+8yAJU4sqLBIwKLBEicWVFiiylUTdFS5KixR5aqwRJWrwbLq7DMLlujlqrBEL1eFJXq5KiwSsGiwxIkFrbGw7OyzcfG/7OwzA5Y4saDCEicWNFiWnX1mwBJVrpagY/aZDktUuSosErBosMSJBRWW6OWqsEQvV4UlerkqLNHL1WBZdfaZ0VhYdvbZuPhfdvaZAUucWFBhkYBFgyVOLKiwRJWrJuioclVYospVYYkqV4Nl1dlnFizRy1VhiV6uCkv0clVYJGDRYIkTC1pjYdnZZ+Pif9nZZwYscWJBhSVOLGiwLDv7zIAlqlwtQcfsMx2WqHJVWCRg0WCJEwsqLNHLVWGJXq4KS/RyVViil6vBsursM6OxsOzss3Hxv+zsMwOWOLGgwiIBiwZLnFhQYYkqV03QUeWqsESVq8ISVa4Gy6qzzyxYoperwhK9XBWW6OWqsEjAosESJxa0xsKys8/Gxf+ys88MWOLEggpLnFjQYFl29pkBS1S5WoKO2Wc6LFHlqrBIwKLBEicWVFiil6vCEr1cFZbo5aqwRC9Xg2XV2WdGY2HZ2Wfj4n/Z2WcGLHFiQYVFAhYNljixoMISVa6aoBetcq0EHb1c9SGKXq4CS1l19pkFS1S5KixR5aqwRC9XSdA7aJGgXyfoErPP9IcoTiyosMSJBRWWqHJVWKLK1WCJ2Wdqgo7ZZzoscWJBhSWqXBUWWROW2o4qtzZ+DcuiVa4Fy5upcvN2sYIylS+u/vRJkQvXJpcbt1oV25GrS8t25BLQsB16epdlO3Ix1bgNbUeueCzckcsSy3ZxbDtygrdsR87C1rPqOK9CTzmybHecV6HnBVm2O86r0JN3LNwd51XoGTaW7Y7zKvQ0GOtZdZxXoeeqWLY7zqvQE0os2x3nVehZHxbujvMq9NQMy3bHeRV6/oT1rDrOq9CTHCzbHedV6JkIlu2O8yr0dAELd8d5FVqn37LdcV6FVry3nlXHeRVaO96y3XFehVZht2x3nFeh9cwt3B3nVWhlcMt2x3kVWmPbelYd51VotWrLdsd5FVr32bLdcV6FVlC2cHecV6G1iC3bHedVaFVf61l1nFeh9XEt2x3nVWilWct2x3kVWrPVwt1xXoVWP7Vsd5xXoXVErWfVcV6FVuS0bHecV6G1LS3bHedVaJVIC3fHeRVab9Gy3XFehVYutJ5Vx3kVWgPQst1vXq3QanqW7X7zaoXWpbNw95tX6+Y3r1ZoGTbLdr95tUILmlm4+82rFVoazLAdWr/Lst1xXoVWwrJwd5xXoTWlLNsd51VodSbrWXWcVx3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5Sday3VB3rLVXHekvVsd5SxdZbMmy/bV6lLb20/dMW/e5b3Fi9SN1CTSZPAg+fVz1xUsdbVD6+i/137ecvuW2aPeVijiQ5Lk28m7P/9fdfPvz444d//e3Hn7//7rcPP//069PK7el/9EPS+28V/bK1vPCvRPz08fTTydaiNLOIZhbxzCKZWZRnFpWZRXVmUZtZNOMRPOMRPOMRPOMRPOMRPOMRPOMRPOMRPOMRPOMRPOMRMuMRMuMRMuMR+uGD/XefclmUqb5aJDOL8syiMrOozixqM4v6xCL9t0xrUZpZRDOLZjwiz3hEnvGIPOMR+k8je1eKL4tKkVeL2syiPrFI78Jbi9LMIppZxDOLZGZRnllUZhbNeESZ8Ygy4xF1xiPqH3jEdimJa+cvF70fX51fpYtK99+C77+F3H+LfP8tyv23qNdvkeW4OsvLqyV/3KLdf4t+9y3adv8t0v23oFtskS8xKjfqX2zx+upSLq2GUtrztbV/NIexzBEsc/LZ5uwdlaO5kvdO2NfeU9AMqmgGNTSDOphBfUMzKKEZRGgGMZpBgmYQWqTuaJG6o0XqjhapO1qkThtaqE4bWqxOG1qwThtatE4bWrhO253j9cc9ygl71BP2uEWgbDkde5Tt9R79/nuk7YQ90q33qK/3oBP24BP2uEVU6HTs0Vn5PvIJe5QT9rjFc96PExll2/jVHnSDz1GYLgc5Csvr75zqCXu0E/bot9ij5csesrVXe/B2wh7phD3oxnuk/HoPPmEPOWGPG8SrInL4rrRmVEqlXgJPaS/qpE8NyMQFzJ4KZk8Ds6dj2SMbmD0JzB4Cs4fB7LlFzC31cii4lP46P0k+YY9ywh71hD3aCXv0+++RtxP2SCfsQSfswSfsccJznk94zvMJz3k+4TnPJzzn+YTnvJzwnJcTnvNywnNeTnjOywnPeTnhOS8nPIPlTzyDr47BptJnVtVtalWaWkVTq3hqlUytylOrytSqOrVqyjfqlG+0Kd9oU77RpnyjTflGm/KNNuUbbco32pRvtCnfaFO+0ad8o0/5Rp/yjT7lG33KN/qUb/Qp3+hTvtGnfKPP+AZt29SqNLWKplbx1CqZWpWnVpWpVXVqVZtaNeUbaco30pRvpCnfSFO+kaZ8I035RpryjTTlG2nKN9KUb9CUb9CUb9CUb9CUb9CUb9CUb9CUb9CUb9CUb9CUb/CUb/CUb/CUb/CUb/CUb/CUb/CUb/CUb/CUb/CUb8iUb8iUb8iUb8iUb8iUb8iUb8iUb8iUb8iUb8iUb+Qp38hTvpGnfCNP+Uae8o085Rt5yjfylG/kKd/IU75RpnyjTPlGmfKNMuUbZco3ypRvlCnfKFO+MdUXpam+KE31RWmqL0pTfVGa6ovSVF+UpvqiNNUXpT/RF/2KzPy6w743Bi8d9r3b99xhz+nTFu3+W/S7b/En2rNXb5HuvwXdfwu+/xZy/y3y/bco99/i/k93u//T3e7/dPf7P939/k93v//T3e//dPf7P9397k83603UtO2/X15WbfsvGc+bPP0cvf+Vnq7W+5v7gnSs5RdLm2Je3S7W1UQvL/3r05mQ+96+XH97PuR5pH99+3qD21/kIGrhr2/f7nv7fv3t26FD1+tXt9e7ure7fbr69u3QF2vytefofeJvvP3l5H/L5evb8/W3r5evtr0GR254+/7VY7X/QR9Dg+o/ckSVnJ49rpQ/donhivTNK+ibV/A3r5BvW7H/wU8X6k3E/erLuvwCaf6otqt3EMdL5NuX5G9fUr5xye/7n//73S8fvvv7jz88afQ+/et/fvr+Itm7//nb//378i8XUd9///Lz9z/84z+//PAk7/us7PsECqfynqk8BbInt+I9DfDWn/5MH/+V33PKz3ns6Rqq+4rDf/nzf6nHLdp74ePL+rjH9l62yz9Le5/3f/59/yj/Dw==",
       "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",
-        "notify_created_nullifier_oracle_wrapper",
+        "store_in_execution_cache_oracle_wrapper",
         "directive_invert",
         "directive_integer_quotient",
         "directive_to_radix"
       ],
-      "verification_key": "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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/9VTvQ6CMBBu+YmCMqiJbia+QREMjCbuvkMDMuqAixuPLjXX9FKbMLQ18Uuaa+Hy/ZSDEgUKNSIWkCQHqAnUAL0Px3WGM7NDnmi6LvlrVhaJIZ9D/x9+6sm/gOT3dP9sBjyXQfHjLFJ3Pq4UzYSvzPKb+cy8mci5+kHOEcdM08aghmehoYci3zvYZ4Y+iQVR/3Q0uM9V1YxJvRD4Y/LtHevHWv8WzqnmX9TIwmdX8bwreMdPvG3Lhq81foEA3dM/z8Ie9lOzgDMuiZqN/nVvro/nrScTECRvfuFT84YGAAA=",
-      "debug_symbols": "ndLNCoQgEAfwd5lzh8a+e5VYwspCEA2zhSV699WIaJcuehlmxN/M5b/BwLp1arkc1QJ1s4FQPTVcSTttewSd5kLwqb0/Q+wK4vF/mal042KoNlCTFCNgcnBdZf3IBYM6J/srAiTeIvEWqbfIfAV5vIFxjNVpbJ/ml8I0OVgWxvIwVoSxMogl+MwwLi+GpPhlux3fVHPaCXbGbVxlf0uf+czsL4izVj0bVs1cJG9ptLXBIiLErrWrvw==",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "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"
     },
     {
       "name": "constructor",
@@ -5333,7 +5390,7 @@
         }
       },
       "bytecode": "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",
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "brillig_names": [
         "get_contract_instance_internal",
         "decompose_hint",
@@ -5353,6 +5410,108 @@
         "directive_to_radix"
       ],
       "verification_key": "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"
+    },
+    {
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
+      "abi": {
+        "error_types": {
+          "11091894166229312484": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 20
+          },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "17843811134343075018": {
+            "error_kind": "string",
+            "string": "Stack too deep"
+          },
+          "5019202896831570965": {
+            "error_kind": "string",
+            "string": "attempt to add with overflow"
+          },
+          "8270195893599566439": {
+            "error_kind": "string",
+            "string": "Invalid public keys hint for address"
+          }
+        },
+        "parameters": [
+          {
+            "name": "contract_address",
+            "type": {
+              "fields": [
+                {
+                  "name": "inner",
+                  "type": {
+                    "kind": "field"
+                  }
+                }
+              ],
+              "kind": "struct",
+              "path": "authwit::aztec::protocol_types::address::aztec_address::AztecAddress"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "nonce",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "storage_slot",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "note_type_id",
+            "type": {
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "compute_nullifier",
+            "type": {
+              "kind": "boolean"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "serialized_note",
+            "type": {
+              "kind": "array",
+              "length": 3,
+              "type": {
+                "kind": "field"
+              }
+            },
+            "visibility": "private"
+          }
+        ],
+        "return_type": {
+          "abi_type": {
+            "kind": "array",
+            "length": 4,
+            "type": {
+              "kind": "field"
+            }
+          },
+          "visibility": "public"
+        }
+      },
+      "bytecode": "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",
+      "debug_symbols": "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",
+      "brillig_names": [
+        "compute_note_hash_and_optionally_a_nullifier"
+      ]
     }
   ],
   "outputs": {
@@ -5488,6 +5647,33 @@
     },
     "structs": {
       "functions": [
+        {
+          "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": [
             {
@@ -5671,33 +5857,6 @@
           "kind": "struct",
           "path": "SchnorrAccount::entrypoint_abi"
         },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "signing_pub_key_x",
-                    "type": {
-                      "kind": "field"
-                    }
-                  },
-                  {
-                    "name": "signing_pub_key_y",
-                    "type": {
-                      "kind": "field"
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "SchnorrAccount::constructor_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "SchnorrAccount::constructor_abi"
-        },
         {
           "fields": [
             {
@@ -5729,91 +5888,103 @@
     }
   },
   "file_map": {
-    "101": {
-      "path": "/build-volume/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"
-    },
-    "103": {
+    "102": {
       "path": "/build-volume/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"
+      "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    /// Safety: 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"
     },
-    "106": {
+    "105": {
       "path": "/build-volume/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    // TODO(https://github.com/AztecProtocol/aztec-packages/issues/10537): Replace use of sha256\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"
     },
+    "109": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/macros/functions/initialization_utils.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\n/// This function is not only used in macros but it's also used by external people to check that an instance has been\n/// initialized with the correct constructor arguments. Don't hide this unless you implement factory functionality.\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"
+    },
     "118": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/note/discovery/mod.nr",
+      "source": "use std::static_assert;\n\nuse crate::{\n    context::unconstrained_context::UnconstrainedContext, note::note_header::NoteHeader,\n    oracle::note_discovery::deliver_note, utils::array,\n};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    constants::{MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS},\n    hash::compute_note_hash_nonce,\n};\n\n// We reserve two fields in the note log that are not part of the note content: one for the storage slot, and one for\n// the note type id.\nglobal NOTE_LOG_RESERVED_FIELDS: u32 = 2;\npub global MAX_NOTE_SERIALIZED_LEN: u32 = PRIVATE_LOG_SIZE_IN_FIELDS - NOTE_LOG_RESERVED_FIELDS;\n\npub struct NoteHashesAndNullifier {\n    pub note_hash: Field,\n    pub unique_note_hash: Field,\n    pub inner_nullifier: Field,\n}\n\n/// Processes a log given its plaintext by trying to find notes encoded in it. This process involves the discovery of\n/// the nonce of any such notes, which requires knowledge of the transaction hash in which the notes would've been\n/// created, along with the list of unique note hashes in said transaction.\n///\n/// Additionally, this requires a `compute_note_hash_and_nullifier` lambda that is able to compute these values for any\n/// note in the contract given their contents. A typical implementation of such a function would look like this:\n///\n/// ```\n/// |serialized_note_content, note_header, note_type_id| {\n///     let hashes = if note_type_id == MyNoteType::get_note_type_id() {\n///         assert(serialized_note_content.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///         dep::aztec::note::utils::compute_note_hash_and_optionally_a_nullifier(\n///             MyNoteType::deserialize_content,\n///             note_header,\n///             true,\n///             serialized_note_content.storage(),\n///         )\n///     } else {\n///         panic(f\"Unknown note type id {note_type_id}\")\n///     };\n///\n///     Option::some(dep::aztec::oracle::management::NoteHashesAndNullifier {\n///         note_hash: hashes[0],\n///         unique_note_hash: hashes[1],\n///         inner_nullifier: hashes[3],\n///     })\n/// }\n/// ```\npub unconstrained fn do_process_log<Env>(\n    context: UnconstrainedContext,\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n    tx_hash: Field,\n    unique_note_hashes_in_tx: BoundedVec<Field, MAX_NOTE_HASHES_PER_TX>,\n    first_nullifier_in_tx: Field,\n    recipient: AztecAddress,\n    compute_note_hash_and_nullifier: fn[Env](BoundedVec<Field, MAX_NOTE_SERIALIZED_LEN>, NoteHeader, Field) -> Option<NoteHashesAndNullifier>,\n) {\n    let (storage_slot, note_type_id, serialized_note_content) =\n        destructure_log_plaintext(log_plaintext);\n\n    // We need to find the note's nonce, which is the one that results in one of the unique note hashes from tx_hash\n    for_each_in_bounded_vec(\n        unique_note_hashes_in_tx,\n        |expected_unique_note_hash, i| {\n            let candidate_nonce = compute_note_hash_nonce(first_nullifier_in_tx, i);\n\n            let header = NoteHeader::new(context.this_address(), candidate_nonce, storage_slot);\n\n            // TODO(#11157): handle failed note_hash_and_nullifier computation\n            let hashes = compute_note_hash_and_nullifier(\n                serialized_note_content,\n                header,\n                note_type_id,\n            )\n                .unwrap();\n\n            if hashes.unique_note_hash == expected_unique_note_hash {\n                // TODO(#10726): push these into a vec to deliver all at once instead of having one oracle call per note\n\n                assert(\n                    deliver_note(\n                        context.this_address(), // TODO(#10727): allow other contracts to deliver notes\n                        storage_slot,\n                        candidate_nonce,\n                        serialized_note_content,\n                        hashes.note_hash,\n                        hashes.inner_nullifier,\n                        tx_hash,\n                        recipient,\n                    ),\n                    \"Failed to deliver note\",\n                );\n\n                // We don't exit the loop - it is possible (though rare) for the exact same note content to be present\n                // multiple times in the same transaction with different nonces. This typically doesn't happen due to\n                // notes containing random values in order to hide their contents.\n            }\n        },\n    );\n}\n\nunconstrained fn destructure_log_plaintext(\n    log_plaintext: BoundedVec<Field, PRIVATE_LOG_SIZE_IN_FIELDS>,\n) -> (Field, Field, BoundedVec<Field, MAX_NOTE_SERIALIZED_LEN>) {\n    assert(log_plaintext.len() >= NOTE_LOG_RESERVED_FIELDS);\n\n    // If NOTE_LOG_RESERVED_FIELDS is changed, causing the assertion below to fail, then the declarations for\n    // `storage_slot` and `note_type_id` must be updated as well.\n    static_assert(\n        NOTE_LOG_RESERVED_FIELDS == 2,\n        \"unepxected value for NOTE_LOG_RESERVED_FIELDS\",\n    );\n    let storage_slot = log_plaintext.get(0);\n    let note_type_id = log_plaintext.get(1);\n\n    let serialized_note_content = array::subbvec(log_plaintext, NOTE_LOG_RESERVED_FIELDS);\n\n    (storage_slot, note_type_id, serialized_note_content)\n}\n\nfn for_each_in_bounded_vec<T, let MaxLen: u32, Env>(\n    vec: BoundedVec<T, MaxLen>,\n    f: fn[Env](T, u32) -> (),\n) {\n    for i in 0..MaxLen {\n        if i < vec.len() {\n            f(vec.get_unchecked(i), i);\n        }\n    }\n}\n"
+    },
+    "119": {
       "path": "/build-volume/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;\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    context.push_nullifier_for_note_hash(nullifier, notification_note_hash)\n}\n"
     },
-    "120": {
+    "121": {
       "path": "/build-volume/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"
     },
-    "122": {
+    "123": {
       "path": "/build-volume/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"
+      "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    /// Safety: Constraining that we got a valid note from the oracle is fairly straightforward: all we need to do\n    /// is check that the metadata is correct, and that the note exists.\n    let note = unsafe { get_note_internal(storage_slot) };\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    /// Safety: The notes are constrained below.\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"
     },
-    "128": {
+    "129": {
       "path": "/build-volume/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"
     },
-    "130": {
+    "131": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/call_private_function.nr",
       "source": "use dep::protocol_types::{\n    abis::function_selector::FunctionSelector, address::AztecAddress, utils::reader::Reader,\n};\n\n#[oracle(callPrivateFunction)]\nunconstrained fn call_private_function_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _start_side_effect_counter: u32,\n    _is_static_call: bool,\n) -> [Field; 2] {}\n\npub unconstrained fn call_private_function_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    start_side_effect_counter: u32,\n    is_static_call: bool,\n) -> (u32, Field) {\n    let fields = call_private_function_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        start_side_effect_counter,\n        is_static_call,\n    );\n\n    let mut reader = Reader::new(fields);\n    let end_side_effect_counter = reader.read_u32();\n    let returns_hash = reader.read();\n\n    (end_side_effect_counter, returns_hash)\n}\n"
     },
-    "131": {
+    "132": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
-      "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    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"
+      "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "132": {
+    "133": {
       "path": "/build-volume/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"
     },
-    "133": {
+    "134": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/execution_cache.nr",
-      "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\n/// Stores values represented as array in execution cache to be later obtained by its hash.\npub fn store_array<let N: u32>(values: [Field; N]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_array_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n    let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn store_array_in_execution_cache_oracle_wrapper<let N: u32>(values: [Field; N]) {\n    let _ = store_array_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(storeArrayInExecutionCache)]\nunconstrained fn store_array_in_execution_cache_oracle<let N: u32>(_args: [Field; N]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
+      "source": "/// Stores values represented as slice in execution cache to be later obtained by its hash.\npub fn store(values: [Field]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call. When loading the values, however, the caller must check that the values are indeed the preimage.\n    unsafe { store_in_execution_cache_oracle_wrapper(values) };\n}\n\npub unconstrained fn store_in_execution_cache_oracle_wrapper(values: [Field]) {\n    let _ = store_in_execution_cache_oracle(values);\n}\n\npub unconstrained fn load<let N: u32>(hash: Field) -> [Field; N] {\n    load_from_execution_cache_oracle(hash)\n}\n\n#[oracle(storeInExecutionCache)]\nunconstrained fn store_in_execution_cache_oracle(_values: [Field]) -> Field {}\n\n#[oracle(loadFromExecutionCache)]\nunconstrained fn load_from_execution_cache_oracle<let N: u32>(_hash: Field) -> [Field; N] {}\n"
     },
-    "134": {
+    "135": {
       "path": "/build-volume/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) = unsafe { 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) = unsafe { 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) =\n        unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
+      "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    /// Safety: The to_address function combines all values in the instance object to produce an address,\n    /// so by checking that we get the expected address we validate the entire struct.\n    let instance =\n        unsafe { ContractInstance::deserialize(get_contract_instance_internal(address)) };\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    /// Safety: AVM opcodes are constrained by the AVM itself\n    let (member, exists) = unsafe { 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    /// Safety: AVM opcodes are constrained by the AVM itself\n    let (member, exists) = unsafe { 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    /// Safety: AVM opcodes are constrained by the AVM itself\n    let (member, exists) =\n        unsafe { get_contract_instance_initialization_hash_internal_avm(address) };\n    if exists {\n        Option::some(member)\n    } else {\n        Option::none()\n    }\n}\n"
     },
-    "137": {
+    "138": {
       "path": "/build-volume/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"
     },
-    "139": {
+    "140": {
       "path": "/build-volume/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"
     },
-    "140": {
+    "141": {
       "path": "/build-volume/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"
     },
-    "143": {
-      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
-      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    // 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\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    // 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"
+    "144": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/note_discovery.nr",
+      "source": "use crate::note::discovery::MAX_NOTE_SERIALIZED_LEN;\nuse dep::protocol_types::address::AztecAddress;\n\n/// Informs PXE of a note's existence so that it can later retrieved by the `getNotes` oracle. The note will be scoped\n/// to `contract_address`, meaning other contracts will not be able to access it unless authorized.\n///\n/// The note's `content` is what `getNotes` will later return. PXE indexes notes by `storage_slot`, so this value is\n/// typically used to filter notes that correspond to different state variables. `note_hash` and `nullifier` are the\n/// inner hashes, i.e. the raw hashes returned by `NoteInterface::compute_note_hash` and\n/// `NullifiableNote::compute_nullifier`. PXE will verify that the siloed unique note hash was inserted into the tree at\n/// `tx_hash`, and will store the nullifier to later check for nullification.\n///\n/// `recipient` is the account to which the note was sent to. Other accounts will not be able to access this note (e.g.\n/// other accounts will not be able to see one another's token balance notes, even in the same PXE) unless authorized.\n///\n/// Returns true if the note was sucessfully delivered and added to PXE's database.\npub unconstrained fn deliver_note(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    content: BoundedVec<Field, MAX_NOTE_SERIALIZED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {\n    deliver_note_oracle(\n        contract_address,\n        storage_slot,\n        nonce,\n        content,\n        note_hash,\n        nullifier,\n        tx_hash,\n        recipient,\n    )\n}\n\n#[oracle(deliverNote)]\nunconstrained fn deliver_note_oracle(\n    contract_address: AztecAddress,\n    storage_slot: Field,\n    nonce: Field,\n    content: BoundedVec<Field, MAX_NOTE_SERIALIZED_LEN>,\n    note_hash: Field,\n    nullifier: Field,\n    tx_hash: Field,\n    recipient: AztecAddress,\n) -> bool {}\n"
     },
     "145": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/notes.nr",
+      "source": "use crate::{note::{note_header::NoteHeader, note_interface::NoteInterface}, utils::array};\n\nuse dep::protocol_types::{\n    address::AztecAddress,\n    indexed_tagging_secret::{INDEXED_TAGGING_SECRET_LENGTH, IndexedTaggingSecret},\n};\n\n/// Notifies the simulator that a note has been created, so that it can be returned in future read requests in the same\n/// transaction. This note should only be added to the non-volatile database if found in an actual block.\npub fn notify_created_note<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            serialized_note,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    serialized_note: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        serialized_note,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _serialized_note: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::deserialize_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
+    },
+    "147": {
       "path": "/build-volume/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"
     },
-    "150": {
+    "153": {
       "path": "/build-volume/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    fn get_storage_slot(self) -> Field {\n        self.storage_slot\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"
+      "source": "use dep::protocol_types::{\n    constants::GENERATOR_INDEX__INITIALIZATION_NULLIFIER, hash::poseidon2_hash_with_separator,\n    traits::Packable,\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: Packable<N>,\n{\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\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"
     },
     "17": {
       "path": "std/embedded_curve_ops.nr",
       "source": "use crate::cmp::Eq;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point, if is_infinite is false.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0, is_infinite: true }\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.is_infinite & b.is_infinite)\n            | ((self.is_infinite == b.is_infinite) & (self.x == b.x) & (self.y == b.y))\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    //Bytes to scalar: take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\n// Computes a multi scalar multiplication over the embedded curve.\n// For bn254, We have Grumpkin and Baby JubJub.\n// For bls12-381, we have JubJub and Bandersnatch.\n//\n// The embedded curve being used is decided by the\n// underlying proof system.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    let point_array = multi_scalar_mul_array_return(points, scalars);\n    EmbeddedCurvePoint { x: point_array[0], y: point_array[1], is_infinite: point_array[2] as bool }\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> [Field; 3] {}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    let g1 = EmbeddedCurvePoint {\n        x: 1,\n        y: 17631683881184975370165255887551781615748388533673675138860,\n        is_infinite: false,\n    };\n    multi_scalar_mul([g1], [scalar])\n}\n\n/// This function only assumes that the points are on the curve\n/// It handles corner cases around the infinity point causing some overhead compared to embedded_curve_add_not_nul and embedded_curve_add_unsafe\n// This is a hack because returning an `EmbeddedCurvePoint` from a foreign function in brillig returns a [BrilligVariable::SingleAddr; 2] rather than BrilligVariable::BrilligArray\n// as is defined in the brillig bytecode format. This is a workaround which allows us to fix this without modifying the serialization format.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    let x_coordinates_match = point1.x == point2.x;\n    let y_coordinates_match = point1.y == point2.y;\n    let double_predicate = (x_coordinates_match & y_coordinates_match);\n    let infinity_predicate = (x_coordinates_match & !y_coordinates_match);\n    let point1_1 = EmbeddedCurvePoint {\n        x: point1.x + (x_coordinates_match as Field),\n        y: point1.y,\n        is_infinite: x_coordinates_match,\n    };\n    // point1_1 is guaranteed to have a different abscissa than point2\n    let mut result = embedded_curve_add_unsafe(point1_1, point2);\n    result.is_infinite = x_coordinates_match;\n\n    // dbl if x_match, y_match\n    let double = embedded_curve_add_unsafe(point1, point1);\n    result = if double_predicate { double } else { result };\n\n    // infinity if x_match, !y_match\n    if point1.is_infinite {\n        result = point2;\n    }\n    if point2.is_infinite {\n        result = point1;\n    }\n    let mut result_is_infinity = infinity_predicate & (!point1.is_infinite & !point2.is_infinite);\n    result.is_infinite = result_is_infinity | (point1.is_infinite & point2.is_infinite);\n    result\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n) -> [Field; 3] {}\n\n/// This function assumes that:\n/// The points are on the curve, and\n/// The points don't share an x-coordinate, and\n/// Neither point is the infinity point.\n/// If it is used with correct input, the function ensures the correct non-zero result is returned.\n/// Except for points on the curve, the other assumptions are checked by the function. It will cause assertion failure if they are not respected.\npub fn embedded_curve_add_not_nul(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    assert(point1.x != point2.x);\n    assert(!point1.is_infinite);\n    assert(!point2.is_infinite);\n    embedded_curve_add_unsafe(point1, point2)\n}\n\n/// Unsafe ec addition\n/// If the inputs are the same, it will perform a doubling, but only if point1 and point2 are the same variable.\n/// If they have the same value but are different variables, the result will be incorrect because in this case\n/// it assumes (but does not check) that the points' x-coordinates are not equal.\n/// It also assumes neither point is the infinity point.\npub fn embedded_curve_add_unsafe(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    let point_array = embedded_curve_add_array_return(point1, point2);\n    let x = point_array[0];\n    let y = point_array[1];\n\n    EmbeddedCurvePoint { x, y, is_infinite: false }\n}\n"
     },
-    "176": {
+    "179": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
-      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must 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"
+      "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
     "18": {
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    /// Safety: borrow is enforced to be boolean due to its type.\n    /// if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    /// if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        /*@safety: borrow is enforced to be boolean due to its type.\n            if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n            if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n        */\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        /// Safety: decomposition is properly checked below\n        unsafe {\n            /*@safety: decomposition is properly checked below*/\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            /// Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        /// Safety: unsafe in unconstrained\n        unsafe {\n            //@safety: unsafe in unconstrained\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        /// Safety: Take a hint of the comparison and verify it\n        unsafe {\n            //@safety: Take a hint of the comparison and verify it\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
     "180": {
+      "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/array/subbvec.nr",
+      "source": "use crate::utils::array;\n\n/// Returns `DST_MAX_LEN` elements from a source BoundedVec, starting at `offset`. `offset` must not be larger than the\n/// original length, and `DST_LEN` must not be larger than the total number of elements past `offset` (including the\n/// zeroed elements past `len()`).\n///\n/// Only elements at the beginning of the vector can be removed: it is not possible to also remove elements at the end\n/// of the vector by passing a value for `DST_LEN` that is smaller than `len() - offset`.\n///\n/// Examples:\n/// ```\n/// let foo = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n/// assert_eq(subbvec(foo, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n///\n/// let bar: BoundedVec<_, 1> = subbvec(foo, 2); // fails - we can't return just 1 element since 3 remain\n/// let baz: BoundedVec<_, 10> = subbvec(foo, 3); // fails - we can't return 10 elements since only 7 remain\n/// ```\npub fn subbvec<T, let SRC_MAX_LEN: u32, let DST_MAX_LEN: u32>(\n    vec: BoundedVec<T, SRC_MAX_LEN>,\n    offset: u32,\n) -> BoundedVec<T, DST_MAX_LEN> {\n    // from_parts_unchecked does not verify that the elements past len are zeroed, but that is not an issue in our case\n    // because we're constructing the new storage array as a subarray of the original one (which should have zeroed\n    // storage past len), guaranteeing correctness. This is because `subarray` does not allow extending arrays past\n    // their original length.\n    BoundedVec::from_parts_unchecked(array::subarray(vec.storage(), offset), vec.len() - offset)\n}\n\nmod test {\n    use super::subbvec;\n\n    #[test]\n    unconstrained fn subbvec_empty() {\n        let bvec = BoundedVec::<Field, 0>::from_array([]);\n        assert_eq(subbvec(bvec, 0), bvec);\n    }\n\n    #[test]\n    unconstrained fn subbvec_complete() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), bvec);\n\n        let smaller_capacity = BoundedVec::<_, 5>::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 0), smaller_capacity);\n    }\n\n    #[test]\n    unconstrained fn subbvec_partial() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 8>::from_array([3, 4, 5]));\n        assert_eq(subbvec(bvec, 2), BoundedVec::<_, 3>::from_array([3, 4, 5]));\n    }\n\n    #[test]\n    unconstrained fn subbvec_into_empty() {\n        let bvec: BoundedVec<_, 10> = BoundedVec::from_array([1, 2, 3, 4, 5]);\n        assert_eq(subbvec(bvec, 5), BoundedVec::<_, 5>::from_array([]));\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_offset_past_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n        let _: BoundedVec<_, 1> = subbvec(bvec, 6);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subbvec_insufficient_dst_len() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // We're not providing enough space to hold all of the items inside the original BoundedVec. subbvec can cause\n        // for the capacity to reduce, but not the length (other than by len - offset).\n        let _: BoundedVec<_, 1> = subbvec(bvec, 2);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_causes_enlarge() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // subbvec does not supprt capacity increases\n        let _: BoundedVec<_, 11> = subbvec(bvec, 0);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subbvec_dst_len_too_large_for_offset() {\n        let bvec = BoundedVec::<_, 10>::from_array([1, 2, 3, 4, 5]);\n\n        // This effectively requests a capacity increase, since there'd be just one element plus the 5 empty slots,\n        // which is less than 7.\n        let _: BoundedVec<_, 7> = subbvec(bvec, 4);\n    }\n}\n"
+    },
+    "184": {
       "path": "/build-volume/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"
     },
@@ -5825,67 +5996,71 @@
       "path": "std/hash/mod.nr",
       "source": "pub mod poseidon;\npub mod poseidon2;\npub mod keccak;\npub mod sha256;\npub mod sha512;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::uint128::U128;\n\n// Kept for backwards compatibility\npub use sha256::{digest, sha256, sha256_compression, sha256_var};\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    /// Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n    let mut sum = 0;\n\n    for input in inputs {\n        let input_bytes: [u8; 32] = input.to_le_bytes();\n        sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n    }\n\n    sum\n}\n\n// docs:start:keccak256\npub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]\n// docs:end:keccak256\n{\n    crate::hash::keccak::keccak256(input, message_size)\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: StructDefinition) -> Quoted {\n    let name = quote { Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher<H>\nwhere\n    H: Hasher,\n{\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher<H> for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl Hash for U128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self.lo as Field);\n        H::write(state, self.hi as Field);\n    }\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
     },
-    "232": {
+    "237": {
       "path": "/build-volume/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"
     },
-    "239": {
+    "244": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, 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"
+      "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n};\n\n// We do below because `use crate::point::Point;` does not work\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\n\nuse crate::public_keys::AddressPoint;\nuse ec::{pow, sqrt};\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\n\n// Aztec address\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Eq for AztecAddress {\n    fn eq(self, other: Self) -> bool {\n        self.to_field() == other.to_field()\n    }\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl Serialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn serialize(self: Self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        [self.to_field()]\n    }\n}\n\nimpl Deserialize<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn deserialize(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        FromField::from_field(fields[0])\n    }\n}\n\n/// We implement the Packable trait for AztecAddress because it can be stored in contract's storage (and there\n/// the implementation of Packable is required).\nimpl Packable<AZTEC_ADDRESS_LENGTH> for AztecAddress {\n    fn pack(self) -> [Field; AZTEC_ADDRESS_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(fields: [Field; AZTEC_ADDRESS_LENGTH]) -> Self {\n        Self::deserialize(fields)\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    pub fn to_address_point(self) -> AddressPoint {\n        // We compute the address point by taking our address, setting it to x, and then solving for y in the\n        // equation which defines our bn curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = pow(x, 3) - 17;\n\n        // TODO (#8970): Handle cases where we cannot recover a point from an address\n        let mut y = sqrt(y_squared);\n\n        // If we get a negative y coordinate (any y where y > MAX_FIELD_VALUE / 2), we pin it to the\n        // positive one (any value where y <= MAX_FIELD_VALUE / 2) by subtracting it from the Field modulus\n        // note: The field modulus is MAX_FIELD_VALUE + 1\n        if (!(y.lt(MAX_FIELD_VALUE / 2) | y.eq(MAX_FIELD_VALUE / 2))) {\n            y = (MAX_FIELD_VALUE + 1) - y;\n        }\n\n        AddressPoint { inner: Point { x: self.inner, y, is_infinite: false } }\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        );\n\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secrect can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_private_function(\n        function_selector: FunctionSelector,\n        function_vk_hash: Field,\n        function_leaf_membership_witness: MembershipWitness<FUNCTION_TREE_HEIGHT>,\n        contract_class_artifact_hash: Field,\n        contract_class_public_bytecode_commitment: Field,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let private_functions_root = private_functions_root_from_siblings(\n            function_selector,\n            function_vk_hash,\n            function_leaf_membership_witness.leaf_index,\n            function_leaf_membership_witness.sibling_path,\n        );\n\n        let contract_class_id = ContractClassId::compute(\n            contract_class_artifact_hash,\n            private_functions_root,\n            contract_class_public_bytecode_commitment,\n        );\n\n        // Compute contract address using the preimage which includes the class_id.\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let public_keys = PublicKeys {\n        npk_m: NpkM {\n            inner: Point {\n                x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n                y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n                is_infinite: false,\n            },\n        },\n        ivpk_m: IvpkM {\n            inner: Point {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n                is_infinite: false,\n            },\n        },\n        ovpk_m: OvpkM {\n            inner: Point {\n                x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n                y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n                is_infinite: false,\n            },\n        },\n        tpk_m: TpkM {\n            inner: Point {\n                x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n                y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n                is_infinite: false,\n            },\n        },\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address);\n\n    // The following value was generated by `derivation.test.ts`.\n    // --> Run the test with AZTEC_GENERATE_TEST_DATA=1 flag to update test data.\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x24e4646f58b9fbe7d38e317db8d5636c423fbbdfbe119fc190fe9c64747e0c62;\n    assert(address.to_field() == expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], GENERATOR_INDEX__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x23ce9be3fa3c846b0f9245cc796902e731d04f086e8a42473bb29e405fc98075;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(Deserialize::deserialize(address.serialize()), address);\n}\n"
     },
-    "242": {
+    "247": {
       "path": "/build-volume/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"
     },
-    "244": {
+    "249": {
       "path": "/build-volume/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"
     },
-    "249": {
+    "254": {
       "path": "/build-volume/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"
+      "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, FromField, Hash, Serialize, ToField},\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"
+    },
+    "26": {
+      "path": "std/hash/poseidon2.nr",
+      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
     },
-    "255": {
+    "260": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
-      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    // 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"
+      "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "256": {
+    "261": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
-      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::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    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_unencrypted_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_unencrypted_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_unencrypted_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> 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"
+      "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = std::hash::sha256(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = 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"
     },
-    "257": {
+    "262": {
       "path": "/build-volume/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"
-    },
-    "26": {
-      "path": "std/hash/poseidon2.nr",
-      "source": "use crate::default::Default;\nuse crate::hash::Hasher;\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = crate::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: &[] }\n    }\n}\n"
+      "source": "use crate::traits::{Deserialize, Serialize, ToField};\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"
     },
     "27": {
       "path": "std/hash/sha256.nr",
       "source": "use crate::runtime::is_unconstrained;\n\n// Implementation of SHA-256 mapping a byte array of variable length to\n// 32 bytes.\n\n// A message block is up to 64 bytes taken from the input.\nglobal BLOCK_SIZE: u32 = 64;\n\n// The first index in the block where the 8 byte message size will be written.\nglobal MSG_SIZE_PTR: u32 = 56;\n\n// Size of the message block when packed as 4-byte integer array.\nglobal INT_BLOCK_SIZE: u32 = 16;\n\n// A `u32` integer consists of 4 bytes.\nglobal INT_SIZE: u32 = 4;\n\n// Index of the integer in the `INT_BLOCK` where the length is written.\nglobal INT_SIZE_PTR: u32 = MSG_SIZE_PTR / INT_SIZE;\n\n// Magic numbers for bit shifting.\n// Works with actual bit shifting as well as the compiler turns them into * and /\n// but circuit execution appears to be 10% faster this way.\nglobal TWO_POW_8: u32 = 256;\nglobal TWO_POW_16: u32 = TWO_POW_8 * 256;\nglobal TWO_POW_24: u32 = TWO_POW_16 * 256;\nglobal TWO_POW_32: u64 = TWO_POW_24 as u64 * 256;\n\n// Index of a byte in a 64 byte block; ie. 0..=63\ntype BLOCK_BYTE_PTR = u32;\n\n// The foreign function to compress blocks works on 16 pieces of 4-byte integers, instead of 64 bytes.\ntype INT_BLOCK = [u32; INT_BLOCK_SIZE];\n\n// A message block is a slice of the original message of a fixed size,\n// potentially padded with zeros, with neighbouring 4 bytes packed into integers.\ntype MSG_BLOCK = INT_BLOCK;\n\n// The hash is 32 bytes.\ntype HASH = [u8; 32];\n\n// The state accumulates the blocks.\n// Its overall size is the same as the `HASH`.\ntype STATE = [u32; 8];\n\n// Deprecated in favour of `sha256_var`\n// docs:start:sha256\npub fn sha256<let N: u32>(input: [u8; N]) -> HASH\n// docs:end:sha256\n{\n    digest(input)\n}\n\n#[foreign(sha256_compression)]\npub fn sha256_compression(_input: INT_BLOCK, _state: STATE) -> STATE {}\n\n// SHA-256 hash function\n#[no_predicates]\npub fn digest<let N: u32>(msg: [u8; N]) -> HASH {\n    sha256_var(msg, N as u64)\n}\n\n// Variable size SHA-256 hash\npub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {\n    let message_size = message_size as u32;\n    let num_blocks = N / BLOCK_SIZE;\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n    // Intermediate hash, starting with the canonical initial value\n    let mut h: STATE = [\n        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635,\n        1541459225,\n    ];\n    // Pointer into msg_block on a 64 byte scale\n    let mut msg_byte_ptr = 0;\n    for i in 0..num_blocks {\n        let msg_start = BLOCK_SIZE * i;\n        /// Safety: the msg_block is checked below in verify_msg_block\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            // Verify the block we are compressing was appropriately constructed\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n\n        // If the block is filled, compress it.\n        // An un-filled block is handled after this loop.\n        if (msg_start < message_size) & (msg_byte_ptr == BLOCK_SIZE) {\n            h = sha256_compression(msg_block, h);\n        }\n    }\n\n    let modulo = N % BLOCK_SIZE;\n    // Handle setup of the final msg block.\n    // This case is only hit if the msg is less than the block size,\n    // or our message cannot be evenly split into blocks.\n    if modulo != 0 {\n        let msg_start = BLOCK_SIZE * num_blocks;\n        /// Safety: the msg_block is checked below in verify_msg_block\n        let (new_msg_block, new_msg_byte_ptr) =\n            unsafe { build_msg_block(msg, message_size, msg_start) };\n\n        if msg_start < message_size {\n            msg_block = new_msg_block;\n        }\n\n        if !is_unconstrained() {\n            let new_msg_byte_ptr = verify_msg_block(msg, message_size, msg_block, msg_start);\n            if msg_start < message_size {\n                msg_byte_ptr = new_msg_byte_ptr;\n                verify_msg_block_padding(msg_block, msg_byte_ptr);\n            }\n        } else if msg_start < message_size {\n            msg_byte_ptr = new_msg_byte_ptr;\n        }\n    }\n\n    // If we had modulo == 0 then it means the last block was full,\n    // and we can reset the pointer to zero to overwrite it.\n    if msg_byte_ptr == BLOCK_SIZE {\n        msg_byte_ptr = 0;\n    }\n\n    // Pad the rest such that we have a [u32; 2] block at the end representing the length\n    // of the message, and a block of 1 0 ... 0 following the message (i.e. [1 << 7, 0, ..., 0]).\n    // Here we rely on the fact that everything beyond the available input is set to 0.\n    msg_block = update_block_item(\n        msg_block,\n        msg_byte_ptr,\n        |msg_item| set_item_byte_then_zeros(msg_item, msg_byte_ptr, 1 << 7),\n    );\n    msg_byte_ptr = msg_byte_ptr + 1;\n    let last_block = msg_block;\n\n    // If we don't have room to write the size, compress the block and reset it.\n    if msg_byte_ptr > MSG_SIZE_PTR {\n        h = sha256_compression(msg_block, h);\n        // `attach_len_to_msg_block` will zero out everything after the `msg_byte_ptr`.\n        msg_byte_ptr = 0;\n    }\n\n    /// Safety: the msg_len is checked below in verify_msg_len\n    msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };\n\n    if !is_unconstrained() {\n        verify_msg_len(msg_block, last_block, msg_byte_ptr, message_size);\n    }\n\n    hash_final_block(msg_block, h)\n}\n\n// Take `BLOCK_SIZE` number of bytes from `msg` starting at `msg_start`.\n// Returns the block and the length that has been copied rather than padded with zeros.\nunconstrained fn build_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_start: u32,\n) -> (MSG_BLOCK, BLOCK_BYTE_PTR) {\n    let mut msg_block: MSG_BLOCK = [0; INT_BLOCK_SIZE];\n\n    // We insert `BLOCK_SIZE` bytes (or up to the end of the message)\n    let block_input = if msg_start + BLOCK_SIZE > message_size {\n        if message_size < msg_start {\n            // This function is sometimes called with `msg_start` past the end of the message.\n            // In this case we return an empty block and zero pointer to signal that the result should be ignored.\n            0\n        } else {\n            message_size - msg_start\n        }\n    } else {\n        BLOCK_SIZE\n    };\n\n    // Figure out the number of items in the int array that we have to pack.\n    // e.g. if the input is [0,1,2,3,4,5] then we need to pack it as 2 items: [0123, 4500]\n    let mut int_input = block_input / INT_SIZE;\n    if block_input % INT_SIZE != 0 {\n        int_input = int_input + 1;\n    };\n\n    for i in 0..int_input {\n        let mut msg_item: u32 = 0;\n        // Always construct the integer as 4 bytes, even if it means going beyond the input.\n        for j in 0..INT_SIZE {\n            let k = i * INT_SIZE + j;\n            let msg_byte = if k < block_input {\n                msg[msg_start + k]\n            } else {\n                0\n            };\n            msg_item = lshift8(msg_item, 1) + msg_byte as u32;\n        }\n        msg_block[i] = msg_item;\n    }\n\n    // Returning the index as if it was a 64 byte array.\n    // We have to project it down to 16 items and bit shifting to get a byte back if we need it.\n    (msg_block, block_input)\n}\n\n// Verify the block we are compressing was appropriately constructed by `build_msg_block`\n// and matches the input data. Returns the index of the first unset item.\n// If `message_size` is less than `msg_start` then this is called with the old non-empty block;\n// in that case we can skip verification, ie. no need to check that everything is zero.\nfn verify_msg_block<let N: u32>(\n    msg: [u8; N],\n    message_size: u32,\n    msg_block: MSG_BLOCK,\n    msg_start: u32,\n) -> BLOCK_BYTE_PTR {\n    let mut msg_byte_ptr = 0;\n    let mut msg_end = msg_start + BLOCK_SIZE;\n    if msg_end > N {\n        msg_end = N;\n    }\n    // We might have to go beyond the input to pad the fields.\n    if msg_end % INT_SIZE != 0 {\n        msg_end = msg_end + INT_SIZE - msg_end % INT_SIZE;\n    }\n\n    // Reconstructed packed item.\n    let mut msg_item: u32 = 0;\n\n    // Inclusive at the end so that we can compare the last item.\n    let mut i: u32 = 0;\n    for k in msg_start..=msg_end {\n        if k % INT_SIZE == 0 {\n            // If we consumed some input we can compare against the block.\n            if (msg_start < message_size) & (k > msg_start) {\n                assert_eq(msg_block[i], msg_item as u32);\n                i = i + 1;\n                msg_item = 0;\n            }\n        }\n        // Shift the accumulator\n        msg_item = lshift8(msg_item, 1);\n        // If we have input to consume, add it at the rightmost position.\n        if k < message_size & k < msg_end {\n            msg_item = msg_item + msg[k] as u32;\n            msg_byte_ptr = msg_byte_ptr + 1;\n        }\n    }\n\n    msg_byte_ptr\n}\n\n// Verify the block we are compressing was appropriately padded with zeros by `build_msg_block`.\n// This is only relevant for the last, potentially partially filled block.\nfn verify_msg_block_padding(msg_block: MSG_BLOCK, msg_byte_ptr: BLOCK_BYTE_PTR) {\n    // Check all the way to the end of the block.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_BLOCK_SIZE);\n}\n\n// Verify that a region of ints in the message block are (partially) zeroed,\n// up to an (exclusive) maximum which can either be the end of the block\n// or just where the size is to be written.\nfn verify_msg_block_zeros(\n    msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    max_int_byte_ptr: u32,\n) {\n    // This variable is used to get around the compiler under-constrained check giving a warning.\n    // We want to check against a constant zero, but if it does not come from the circuit inputs\n    // or return values the compiler check will issue a warning.\n    let zero = msg_block[0] - msg_block[0];\n\n    // First integer which is supposed to be (partially) zero.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        let zeros = INT_SIZE - modulo;\n        let mask = if zeros == 3 {\n            TWO_POW_24\n        } else if zeros == 2 {\n            TWO_POW_16\n        } else {\n            TWO_POW_8\n        };\n        assert_eq(msg_block[int_byte_ptr] % mask, zero);\n        int_byte_ptr = int_byte_ptr + 1;\n    }\n\n    // Check the rest of the items.\n    for i in 0..max_int_byte_ptr {\n        if i >= int_byte_ptr {\n            assert_eq(msg_block[i], zero);\n        }\n    }\n}\n\n// Verify that up to the byte pointer the two blocks are equal.\n// At the byte pointer the new block can be partially zeroed.\nfn verify_msg_block_equals_last(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n) {\n    // msg_byte_ptr is the position at which they are no longer have to be the same.\n    // First integer which is supposed to be (partially) zero contains that pointer.\n    let mut int_byte_ptr = msg_byte_ptr / INT_SIZE;\n\n    // Check partial zeros.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Reconstruct the partially zero item from the last block.\n        let last_field = last_block[int_byte_ptr];\n        let mut msg_item: u32 = 0;\n        // Reset to where they are still equal.\n        msg_byte_ptr = msg_byte_ptr - modulo;\n        for i in 0..INT_SIZE {\n            msg_item = lshift8(msg_item, 1);\n            if i < modulo {\n                msg_item = msg_item + get_item_byte(last_field, msg_byte_ptr) as u32;\n                msg_byte_ptr = msg_byte_ptr + 1;\n            }\n        }\n        assert_eq(msg_block[int_byte_ptr], msg_item);\n    }\n\n    for i in 0..INT_SIZE_PTR {\n        if i < int_byte_ptr {\n            assert_eq(msg_block[i], last_block[i]);\n        }\n    }\n}\n\n// Apply a function on the block item which the pointer indicates.\nfn update_block_item<Env>(\n    mut msg_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    f: fn[Env](u32) -> u32,\n) -> MSG_BLOCK {\n    let i = msg_byte_ptr / INT_SIZE;\n    msg_block[i] = f(msg_block[i]);\n    msg_block\n}\n\n// Set the rightmost `zeros` number of bytes to 0.\nfn set_item_zeros(item: u32, zeros: u8) -> u32 {\n    lshift8(rshift8(item, zeros), zeros)\n}\n\n// Replace one byte in the item with a value, and set everything after it to zero.\nfn set_item_byte_then_zeros(msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR, msg_byte: u8) -> u32 {\n    let zeros = INT_SIZE - msg_byte_ptr % INT_SIZE;\n    let zeroed_item = set_item_zeros(msg_item, zeros as u8);\n    let new_item = byte_into_item(msg_byte, msg_byte_ptr);\n    zeroed_item + new_item\n}\n\n// Get a byte of a message item according to its overall position in the `BLOCK_SIZE` space.\nfn get_item_byte(mut msg_item: u32, msg_byte_ptr: BLOCK_BYTE_PTR) -> u8 {\n    // How many times do we have to shift to the right to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    msg_item = rshift8(msg_item, shifts as u8);\n    // At this point the byte we want is in the rightmost position.\n    msg_item as u8\n}\n\n// Project a byte into a position in a field based on the overall block pointer.\n// For example putting 1 into pointer 5 would be 100, because overall we would\n// have [____, 0100] with indexes [0123,4567].\nfn byte_into_item(msg_byte: u8, msg_byte_ptr: BLOCK_BYTE_PTR) -> u32 {\n    let mut msg_item = msg_byte as u32;\n    // How many times do we have to shift to the left to get to the position we want?\n    let max_shifts = INT_SIZE - 1;\n    let shifts = max_shifts - msg_byte_ptr % INT_SIZE;\n    lshift8(msg_item, shifts as u8)\n}\n\n// Construct a field out of 4 bytes.\nfn make_item(b0: u8, b1: u8, b2: u8, b3: u8) -> u32 {\n    let mut item = b0 as u32;\n    item = lshift8(item, 1) + b1 as u32;\n    item = lshift8(item, 1) + b2 as u32;\n    item = lshift8(item, 1) + b3 as u32;\n    item\n}\n\n// Shift by 8 bits to the left between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise multiplies by 256.\nfn lshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        if item == 0 {\n            0\n        } else {\n            // Brillig wouldn't shift 0<<4 without overflow.\n            item << (8 * shifts)\n        }\n    } else {\n        // We can do a for loop up to INT_SIZE or an if-else.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item * TWO_POW_8\n        } else if shifts == 2 {\n            item * TWO_POW_16\n        } else if shifts == 3 {\n            item * TWO_POW_24\n        } else {\n            // Doesn't make sense, but it's most likely called on 0 anyway.\n            0\n        }\n    }\n}\n\n// Shift by 8 bits to the right between 0 and 4 times.\n// Checks `is_unconstrained()` to just use a bitshift if we're running in an unconstrained context,\n// otherwise divides by 256.\nfn rshift8(item: u32, shifts: u8) -> u32 {\n    if is_unconstrained() {\n        item >> (8 * shifts)\n    } else {\n        // Division wouldn't work on `Field`.\n        if shifts == 0 {\n            item\n        } else if shifts == 1 {\n            item / TWO_POW_8\n        } else if shifts == 2 {\n            item / TWO_POW_16\n        } else if shifts == 3 {\n            item / TWO_POW_24\n        } else {\n            0\n        }\n    }\n}\n\n// Zero out all bytes between the end of the message and where the length is appended,\n// then write the length into the last 8 bytes of the block.\nunconstrained fn attach_len_to_msg_block(\n    mut msg_block: MSG_BLOCK,\n    mut msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) -> MSG_BLOCK {\n    // We assume that `msg_byte_ptr` is less than 57 because if not then it is reset to zero before calling this function.\n    // In any case, fill blocks up with zeros until the last 64 bits (i.e. until msg_byte_ptr = 56).\n    // There can be one item which has to be partially zeroed.\n    let modulo = msg_byte_ptr % INT_SIZE;\n    if modulo != 0 {\n        // Index of the block in which we find the item we need to partially zero.\n        let i = msg_byte_ptr / INT_SIZE;\n        let zeros = INT_SIZE - modulo;\n        msg_block[i] = set_item_zeros(msg_block[i], zeros as u8);\n        msg_byte_ptr = msg_byte_ptr + zeros;\n    }\n\n    // The rest can be zeroed without bit shifting anything.\n    for i in (msg_byte_ptr / INT_SIZE)..INT_SIZE_PTR {\n        msg_block[i] = 0;\n    }\n\n    // Set the last two 4 byte ints as the first/second half of the 8 bytes of the length.\n    let len = 8 * message_size;\n    let len_bytes: [u8; 8] = (len as Field).to_be_bytes();\n    for i in 0..=1 {\n        let shift = i * 4;\n        msg_block[INT_SIZE_PTR + i] = make_item(\n            len_bytes[shift],\n            len_bytes[shift + 1],\n            len_bytes[shift + 2],\n            len_bytes[shift + 3],\n        );\n    }\n    msg_block\n}\n\n// Verify that the message length was correctly written by `attach_len_to_msg_block`,\n// and that everything between the byte pointer and the size pointer was zeroed,\n// and that everything before the byte pointer was untouched.\nfn verify_msg_len(\n    msg_block: MSG_BLOCK,\n    last_block: MSG_BLOCK,\n    msg_byte_ptr: BLOCK_BYTE_PTR,\n    message_size: u32,\n) {\n    // Check zeros up to the size pointer.\n    verify_msg_block_zeros(msg_block, msg_byte_ptr, INT_SIZE_PTR);\n\n    // Check that up to the pointer we match the last block.\n    verify_msg_block_equals_last(msg_block, last_block, msg_byte_ptr);\n\n    // We verify the message length was inserted correctly by reversing the byte decomposition.\n    let mut reconstructed_len: u64 = 0;\n    for i in INT_SIZE_PTR..INT_BLOCK_SIZE {\n        reconstructed_len = reconstructed_len * TWO_POW_32;\n        reconstructed_len = reconstructed_len + msg_block[i] as u64;\n    }\n    let len = 8 * message_size as u64;\n    assert_eq(reconstructed_len, len);\n}\n\n// Perform the final compression, then transform the `STATE` into `HASH`.\nfn hash_final_block(msg_block: MSG_BLOCK, mut state: STATE) -> HASH {\n    let mut out_h: HASH = [0; 32]; // Digest as sequence of bytes\n    // Hash final padded block\n    state = sha256_compression(msg_block, state);\n\n    // Return final hash as byte array\n    for j in 0..8 {\n        let h_bytes: [u8; 4] = (state[j] as Field).to_be_bytes();\n        for k in 0..4 {\n            out_h[4 * j + k] = h_bytes[k];\n        }\n    }\n\n    out_h\n}\n\nmod tests {\n    use super::{\n        attach_len_to_msg_block, build_msg_block, byte_into_item, get_item_byte, make_item,\n        set_item_byte_then_zeros, set_item_zeros,\n    };\n    use super::INT_BLOCK;\n    use super::sha256_var;\n\n    #[test]\n    fn smoke_test() {\n        let input = [0xbd];\n        let result = [\n            0x68, 0x32, 0x57, 0x20, 0xaa, 0xbd, 0x7c, 0x82, 0xf3, 0x0f, 0x55, 0x4b, 0x31, 0x3d,\n            0x05, 0x70, 0xc9, 0x5a, 0xcc, 0xbb, 0x7d, 0xc4, 0xb5, 0xaa, 0xe1, 0x12, 0x04, 0xc0,\n            0x8f, 0xfe, 0x73, 0x2b,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        let result = [\n            91, 122, 146, 93, 52, 109, 133, 148, 171, 61, 156, 70, 189, 238, 153, 7, 222, 184, 94,\n            24, 65, 114, 192, 244, 207, 199, 87, 232, 192, 224, 171, 207,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_multiple_over_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99,\n        ];\n        let result = [\n            116, 90, 151, 31, 78, 22, 138, 180, 211, 189, 69, 76, 227, 200, 155, 29, 59, 123, 154,\n            60, 47, 153, 203, 129, 157, 251, 48, 2, 79, 11, 65, 47,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_just_under_block() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59,\n        ];\n        let result = [\n            143, 140, 76, 173, 222, 123, 102, 68, 70, 149, 207, 43, 39, 61, 34, 79, 216, 252, 213,\n            165, 74, 16, 110, 74, 29, 64, 138, 167, 30, 1, 9, 119,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_not_block_multiple() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116, 61, 117, 115, 45, 97, 115,\n            99, 105, 105, 13, 10, 109, 105, 109, 101, 45, 118, 101, 114, 115, 105, 111, 110, 58, 49,\n            46, 48, 32, 40, 77, 97, 99, 32, 79, 83, 32, 88, 32, 77, 97, 105, 108, 32, 49, 54, 46,\n            48, 32, 92, 40, 51, 55, 51, 49, 46, 53, 48, 48, 46, 50, 51, 49, 92, 41, 41, 13, 10, 115,\n            117, 98, 106, 101, 99, 116, 58, 72, 101, 108, 108, 111, 13, 10, 109, 101, 115, 115, 97,\n            103, 101, 45, 105, 100, 58, 60, 56, 70, 56, 49, 57, 68, 51, 50, 45, 66, 54, 65, 67, 45,\n            52, 56, 57, 68, 45, 57, 55, 55, 70, 45, 52, 51, 56, 66, 66, 67, 52, 67, 65, 66, 50, 55,\n            64, 109, 101, 46, 99, 111, 109, 62, 13, 10, 100, 97, 116, 101, 58, 83, 97, 116, 44, 32,\n            50, 54, 32, 65, 117, 103, 32, 50, 48, 50, 51, 32, 49, 50, 58, 50, 53, 58, 50, 50, 32,\n            43, 48, 52, 48, 48, 13, 10, 116, 111, 58, 122, 107, 101, 119, 116, 101, 115, 116, 64,\n            103, 109, 97, 105, 108, 46, 99, 111, 109, 13, 10, 100, 107, 105, 109, 45, 115, 105, 103,\n            110, 97, 116, 117, 114, 101, 58, 118, 61, 49, 59, 32, 97, 61, 114, 115, 97, 45, 115,\n            104, 97, 50, 53, 54, 59, 32, 99, 61, 114, 101, 108, 97, 120, 101, 100, 47, 114, 101,\n            108, 97, 120, 101, 100, 59, 32, 100, 61, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109,\n            59, 32, 115, 61, 49, 97, 49, 104, 97, 105, 59, 32, 116, 61, 49, 54, 57, 51, 48, 51, 56,\n            51, 51, 55, 59, 32, 98, 104, 61, 55, 120, 81, 77, 68, 117, 111, 86, 86, 85, 52, 109, 48,\n            87, 48, 87, 82, 86, 83, 114, 86, 88, 77, 101, 71, 83, 73, 65, 83, 115, 110, 117, 99, 75,\n            57, 100, 74, 115, 114, 99, 43, 118, 85, 61, 59, 32, 104, 61, 102, 114, 111, 109, 58, 67,\n            111, 110, 116, 101, 110, 116, 45, 84, 121, 112, 101, 58, 77, 105, 109, 101, 45, 86, 101,\n            114, 115, 105, 111, 110, 58, 83, 117, 98, 106, 101, 99, 116, 58, 77, 101, 115, 115, 97,\n            103, 101, 45, 73, 100, 58, 68, 97, 116, 101, 58, 116, 111, 59, 32, 98, 61,\n        ];\n        let result = [\n            112, 144, 73, 182, 208, 98, 9, 238, 54, 229, 61, 145, 222, 17, 72, 62, 148, 222, 186,\n            55, 192, 82, 220, 35, 66, 47, 193, 200, 22, 38, 26, 186,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn msg_big_with_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38, 0, 0, 0, 0, 0, 0, 0, 0,\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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        let message_size = 297;\n        assert_eq(sha256_var(input, message_size), result);\n    }\n\n    #[test]\n    fn msg_big_no_padding() {\n        let input = [\n            48, 130, 1, 37, 2, 1, 0, 48, 11, 6, 9, 96, 134, 72, 1, 101, 3, 4, 2, 1, 48, 130, 1, 17,\n            48, 37, 2, 1, 1, 4, 32, 176, 223, 31, 133, 108, 84, 158, 102, 70, 11, 165, 175, 196, 12,\n            201, 130, 25, 131, 46, 125, 156, 194, 28, 23, 55, 133, 157, 164, 135, 136, 220, 78, 48,\n            37, 2, 1, 2, 4, 32, 190, 82, 180, 235, 222, 33, 79, 50, 152, 136, 142, 35, 116, 224, 6,\n            242, 156, 141, 128, 248, 10, 61, 98, 86, 248, 45, 207, 210, 90, 232, 175, 38, 48, 37, 2,\n            1, 3, 4, 32, 0, 194, 104, 108, 237, 246, 97, 230, 116, 198, 69, 110, 26, 87, 17, 89,\n            110, 199, 108, 250, 36, 21, 39, 87, 110, 102, 250, 213, 174, 131, 171, 174, 48, 37, 2,\n            1, 11, 4, 32, 136, 155, 87, 144, 111, 15, 152, 127, 85, 25, 154, 81, 20, 58, 51, 75,\n            193, 116, 234, 0, 60, 30, 29, 30, 183, 141, 72, 247, 255, 203, 100, 124, 48, 37, 2, 1,\n            12, 4, 32, 41, 234, 106, 78, 31, 11, 114, 137, 237, 17, 92, 71, 134, 47, 62, 78, 189,\n            233, 201, 214, 53, 4, 47, 189, 201, 133, 6, 121, 34, 131, 64, 142, 48, 37, 2, 1, 13, 4,\n            32, 91, 222, 210, 193, 62, 222, 104, 82, 36, 41, 138, 253, 70, 15, 148, 208, 156, 45,\n            105, 171, 241, 195, 185, 43, 217, 162, 146, 201, 222, 89, 238, 38, 48, 37, 2, 1, 14, 4,\n            32, 76, 123, 216, 13, 51, 227, 72, 245, 59, 193, 238, 166, 103, 49, 23, 164, 171, 188,\n            194, 197, 156, 187, 249, 28, 198, 95, 69, 15, 182, 56, 54, 38,\n        ];\n        let result = [\n            32, 85, 108, 174, 127, 112, 178, 182, 8, 43, 134, 123, 192, 211, 131, 66, 184, 240, 212,\n            181, 240, 180, 106, 195, 24, 117, 54, 129, 19, 10, 250, 53,\n        ];\n        assert_eq(sha256_var(input, input.len() as u64), result);\n    }\n\n    #[test]\n    fn same_msg_len_variable_padding() {\n        let input = [\n            29, 81, 165, 84, 243, 114, 101, 37, 242, 146, 127, 99, 69, 145, 39, 72, 213, 39, 253,\n            179, 218, 37, 217, 201, 172, 93, 198, 50, 249, 70, 15, 30, 162, 112, 187, 40, 140, 9,\n            236, 53, 32, 44, 38, 163, 113, 254, 192, 197, 44, 89, 71, 130, 169, 242, 17, 211, 214,\n            72, 19, 178, 186, 168, 147, 127, 99, 101, 252, 227, 8, 147, 150, 85, 97, 158, 17, 107,\n            218, 244, 82, 113, 247, 91, 208, 214, 60, 244, 87, 137, 173, 201, 130, 18, 66, 56, 198,\n            149, 207, 189, 175, 120, 123, 224, 177, 167, 251, 159, 143, 110, 68, 183, 189, 70, 126,\n            32, 35, 164, 44, 30, 44, 12, 65, 18, 62, 239, 242, 2, 248, 104, 2, 178, 64, 28, 126, 36,\n            137, 24, 14, 116, 91, 98, 90, 159, 218, 102, 45, 11, 110, 223, 245, 184, 52, 99, 59,\n            245, 136, 175, 3, 72, 164, 146, 145, 116, 22, 66, 24, 49, 193, 121, 3, 60, 37, 41, 97,\n            3, 190, 66, 195, 225, 63, 46, 3, 118, 4, 208, 15, 1, 40, 254, 235, 151, 123, 70, 180,\n            170, 44, 172, 90, 4, 254, 53, 239, 116, 246, 67, 56, 129, 61, 22, 169, 213, 65, 27, 216,\n            116, 162, 239, 214, 207, 126, 177, 20, 100, 25, 48, 143, 84, 215, 70, 197, 53, 65, 70,\n            86, 172, 61, 62, 9, 212, 167, 169, 133, 41, 126, 213, 196, 33, 192, 238, 0, 63, 246,\n            215, 58, 128, 110, 101, 92, 3, 170, 214, 130, 149, 52, 81, 125, 118, 233, 3, 118, 193,\n            104, 207, 120, 115, 77, 253, 191, 122, 0, 107, 164, 207, 113, 81, 169, 36, 201, 228, 74,\n            134, 131, 218, 178, 35, 30, 216, 101, 2, 103, 174, 87, 95, 50, 50, 215, 157, 5, 210,\n            188, 54, 211, 78, 45, 199, 96, 121, 241, 241, 176, 226, 194, 134, 130, 89, 217, 210,\n            186, 32, 140, 39, 91, 103, 212, 26, 87, 32, 72, 144, 228, 230, 117, 99, 188, 50, 15, 69,\n            79, 179, 50, 12, 106, 86, 218, 101, 73, 142, 243, 29, 250, 122, 228, 233, 29, 255, 22,\n            121, 114, 125, 103, 41, 250, 241, 179, 126, 158, 198, 116, 209, 65, 94, 98, 228, 175,\n            169, 96, 3, 9, 233, 133, 214, 55, 161, 164, 103, 80, 85, 24, 186, 64, 167, 92, 131, 53,\n            101, 202, 47, 25, 104, 118, 155, 14, 12, 12, 25, 116, 45, 221, 249, 28, 246, 212, 200,\n            157, 167, 169, 56, 197, 181, 4, 245, 146, 1, 140, 234, 191, 212, 228, 125, 87, 81, 86,\n            119, 30, 63, 129, 143, 32, 96,\n        ];\n\n        // Prepare inputs of different lengths\n        let mut input_511 = [0; 511];\n        let mut input_512 = [0; 512]; // Next block\n        let mut input_575 = [0; 575];\n        let mut input_576 = [0; 576]; // Next block\n        for i in 0..input.len() {\n            input_511[i] = input[i];\n            input_512[i] = input[i];\n            input_575[i] = input[i];\n            input_576[i] = input[i];\n        }\n\n        // Compute hashes of all inputs (with same message length)\n        let fixed_length_hash = super::sha256(input);\n        let var_full_length_hash = sha256_var(input, input.len() as u64);\n        let var_length_hash_511 = sha256_var(input_511, input.len() as u64);\n        let var_length_hash_512 = sha256_var(input_512, input.len() as u64);\n        let var_length_hash_575 = sha256_var(input_575, input.len() as u64);\n        let var_length_hash_576 = sha256_var(input_576, input.len() as u64);\n\n        // All of the above should have produced the same hash\n        assert_eq(var_full_length_hash, fixed_length_hash);\n        assert_eq(var_length_hash_511, fixed_length_hash);\n        assert_eq(var_length_hash_512, fixed_length_hash);\n        assert_eq(var_length_hash_575, fixed_length_hash);\n        assert_eq(var_length_hash_576, fixed_length_hash);\n    }\n\n    #[test]\n    fn test_get_item_byte() {\n        let fld = make_item(10, 20, 30, 40);\n        assert_eq(fld, 0x0a141e28);\n        assert_eq(get_item_byte(fld, 0), 10);\n        assert_eq(get_item_byte(fld, 4), 10);\n        assert_eq(get_item_byte(fld, 6), 30);\n    }\n\n    #[test]\n    fn test_byte_into_item() {\n        let fld = make_item(0, 20, 0, 0);\n        assert_eq(byte_into_item(20, 1), fld);\n        assert_eq(byte_into_item(20, 5), fld);\n    }\n\n    #[test]\n    fn test_set_item_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 0, 0, 0);\n        assert_eq(set_item_zeros(fld0, 3), fld1);\n        assert_eq(set_item_zeros(fld0, 4), 0);\n        assert_eq(set_item_zeros(0, 4), 0);\n    }\n\n    #[test]\n    fn test_set_item_byte_then_zeros() {\n        let fld0 = make_item(10, 20, 30, 40);\n        let fld1 = make_item(10, 50, 0, 0);\n        assert_eq(set_item_byte_then_zeros(fld0, 1, 50), fld1);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_0() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48,\n        ];\n        assert_eq(input.len(), 22);\n\n        /// Safety: testing context\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };\n        assert_eq(msg_byte_ptr, input.len());\n        assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));\n        assert_eq(msg_block[1], make_item(input[4], input[5], input[6], input[7]));\n        assert_eq(msg_block[5], make_item(input[20], input[21], 0, 0));\n        assert_eq(msg_block[6], 0);\n    }\n\n    #[test]\n    fn test_build_msg_block_start_1() {\n        let input = [\n            102, 114, 111, 109, 58, 114, 117, 110, 110, 105, 101, 114, 46, 108, 101, 97, 103, 117,\n            101, 115, 46, 48, 106, 64, 105, 99, 108, 111, 117, 100, 46, 99, 111, 109, 13, 10, 99,\n            111, 110, 116, 101, 110, 116, 45, 116, 121, 112, 101, 58, 116, 101, 120, 116, 47, 112,\n            108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,\n        ];\n        assert_eq(input.len(), 68);\n        /// Safety: test context\n        let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };\n        assert_eq(msg_byte_ptr, 4);\n        assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));\n        assert_eq(msg_block[1], 0);\n    }\n\n    #[test]\n    fn test_attach_len_to_msg_block() {\n        let input: INT_BLOCK = [\n            2152555847, 1397309779, 1936618851, 1262052426, 1936876331, 1985297723, 543702374,\n            1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,\n            1849316213, 1651139939,\n        ];\n        /// Safety: testing context\n        let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };\n        assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);\n        assert_eq(msg_block[1], 0);\n        assert_eq(msg_block[15], 3584);\n    }\n}\n"
     },
-    "272": {
+    "277": {
       "path": "/build-volume/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"
+      "source": "pub use dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse crate::{hash::poseidon2_hash, traits::{Deserialize, Empty, Hash, Packable, 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// TODO(#11356): use compact representation here.\nimpl Packable<POINT_LENGTH> for Point {\n    fn pack(self) -> [Field; POINT_LENGTH] {\n        self.serialize()\n    }\n\n    fn unpack(packed: [Field; POINT_LENGTH]) -> Self {\n        Self::deserialize(packed)\n    }\n}\n"
+    },
+    "278": {
+      "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr",
+      "source": "use crate::constants::TWO_POW_64;\n\n// NB: This is a clone of noir/noir-repo/noir_stdlib/src/hash/poseidon2.nr\n// It exists as we sometimes need to perform custom absorption, but the stdlib version\n// has a private absorb() method (it's also designed to just be a hasher)\n// Can be removed when standalone noir poseidon lib exists: See noir#6679\n\ncomptime global RATE: u32 = 3;\n\npub struct Poseidon2Sponge {\n    pub cache: [Field; 3],\n    pub state: [Field; 4],\n    pub cache_size: u32,\n    pub squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2Sponge {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2Sponge::hash_internal(input, message_size, message_size != N)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2Sponge {\n        let mut result =\n            Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        for i in 0..RATE {\n            // We effectively zero-pad the cache by only adding to the state\n            // cache that is less than the specified `cache_size`\n            if i < self.cache_size {\n                self.state[i] += self.cache[i];\n            }\n        }\n        self.state = std::hash::poseidon2_permutation(self.state, 4);\n    }\n\n    pub fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    pub fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(\n        input: [Field; N],\n        in_len: u32,\n        is_variable_length: bool,\n    ) -> Field {\n        let iv: Field = (in_len as Field) * TWO_POW_64;\n        let mut sponge = Poseidon2Sponge::new(iv);\n        for i in 0..input.len() {\n            if i < in_len {\n                sponge.absorb(input[i]);\n            }\n        }\n\n        // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n        // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n        // fixed-length and variable-length hashes do not collide)\n        if is_variable_length {\n            sponge.absorb(1);\n        }\n        sponge.squeeze()\n    }\n}\n"
     },
-    "281": {
+    "287": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y, DEFAULT_OVPK_M_X,\n        DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y, GENERATOR_INDEX__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::POINT_LENGTH,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse dep::std::embedded_curve_ops::EmbeddedCurvePoint as Point;\nuse std::default::Default;\n\npub global PUBLIC_KEYS_LENGTH: u32 = 12;\n\npub struct PublicKeys {\n    pub npk_m: NpkM,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m: OvpkM,\n    pub tpk_m: TpkM,\n}\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\npub struct NpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for NpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for NpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\n// Note: If we store npk_m_hash directly we can remove this trait implementation. See #8091\nimpl Hash for NpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\npub struct IvpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for IvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct OvpkM {\n    pub inner: Point,\n}\n\nimpl Hash for OvpkM {\n    fn hash(self) -> Field {\n        self.inner.hash()\n    }\n}\n\nimpl ToPoint for OvpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for OvpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\npub struct TpkM {\n    pub inner: Point,\n}\n\nimpl ToPoint for TpkM {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\nimpl Serialize<POINT_LENGTH> for TpkM {\n    fn serialize(self) -> [Field; POINT_LENGTH] {\n        self.inner.serialize()\n    }\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y, is_infinite: false },\n            },\n            ivpk_m: IvpkM {\n                inner: Point { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y, is_infinite: false },\n            },\n            ovpk_m: OvpkM {\n                inner: Point { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y, is_infinite: false },\n            },\n            tpk_m: TpkM {\n                inner: Point { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y, is_infinite: false },\n            },\n        }\n    }\n}\n\nimpl Eq for PublicKeys {\n    fn eq(self, other: PublicKeys) -> bool {\n        (self.npk_m.inner == other.npk_m.inner)\n            & (self.ivpk_m.inner == other.ivpk_m.inner)\n            & (self.ovpk_m.inner == other.ovpk_m.inner)\n            & (self.tpk_m.inner == other.tpk_m.inner)\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            GENERATOR_INDEX__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n}\n\nimpl Serialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn serialize(self) -> [Field; PUBLIC_KEYS_LENGTH] {\n        [\n            self.npk_m.inner.x,\n            self.npk_m.inner.y,\n            self.npk_m.inner.is_infinite as Field,\n            self.ivpk_m.inner.x,\n            self.ivpk_m.inner.y,\n            self.ivpk_m.inner.is_infinite as Field,\n            self.ovpk_m.inner.x,\n            self.ovpk_m.inner.y,\n            self.ovpk_m.inner.is_infinite as Field,\n            self.tpk_m.inner.x,\n            self.tpk_m.inner.y,\n            self.tpk_m.inner.is_infinite as Field,\n        ]\n    }\n}\n\nimpl Deserialize<PUBLIC_KEYS_LENGTH> for PublicKeys {\n    fn deserialize(serialized: [Field; PUBLIC_KEYS_LENGTH]) -> PublicKeys {\n        PublicKeys {\n            npk_m: NpkM {\n                inner: Point {\n                    x: serialized[0],\n                    y: serialized[1],\n                    is_infinite: serialized[2] as bool,\n                },\n            },\n            ivpk_m: IvpkM {\n                inner: Point {\n                    x: serialized[3],\n                    y: serialized[4],\n                    is_infinite: serialized[5] as bool,\n                },\n            },\n            ovpk_m: OvpkM {\n                inner: Point {\n                    x: serialized[6],\n                    y: serialized[7],\n                    is_infinite: serialized[8] as bool,\n                },\n            },\n            tpk_m: TpkM {\n                inner: Point {\n                    x: serialized[9],\n                    y: serialized[10],\n                    is_infinite: serialized[11] as bool,\n                },\n            },\n        }\n    }\n}\n\npub struct AddressPoint {\n    pub inner: Point,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> Point {\n        self.inner\n    }\n}\n\n#[test]\nunconstrained fn compute_public_keys_hash() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let actual = keys.hash();\n    let expected_public_keys_hash =\n        0x0fecd9a32db731fec1fded1b9ff957a1625c069245a3613a2538bd527068b0ad;\n\n    assert(actual.to_field() == expected_public_keys_hash);\n}\n\n#[test]\nunconstrained fn compute_default_hash() {\n    let keys = PublicKeys::default();\n\n    let actual = keys.hash();\n    let test_data_default_hash = 0x1d3bf1fb93ae0e9cda83b203dd91c3bfb492a9aecf30ec90e1057eced0f0e62d;\n\n    assert(actual.to_field() == test_data_default_hash);\n}\n\n#[test]\nunconstrained fn test_public_keys_serialization() {\n    let keys = PublicKeys {\n        npk_m: NpkM { inner: Point { x: 1, y: 2, is_infinite: false } },\n        ivpk_m: IvpkM { inner: Point { x: 3, y: 4, is_infinite: false } },\n        ovpk_m: OvpkM { inner: Point { x: 5, y: 6, is_infinite: false } },\n        tpk_m: TpkM { inner: Point { x: 7, y: 8, is_infinite: false } },\n    };\n\n    let serialized = keys.serialize();\n    let deserialized = PublicKeys::deserialize(serialized);\n\n    assert_eq(keys.npk_m.inner.x, deserialized.npk_m.inner.x);\n    assert_eq(keys.npk_m.inner.y, deserialized.npk_m.inner.y);\n    assert_eq(keys.ivpk_m.inner.x, deserialized.ivpk_m.inner.x);\n    assert_eq(keys.ivpk_m.inner.y, deserialized.ivpk_m.inner.y);\n    assert_eq(keys.ovpk_m.inner.x, deserialized.ovpk_m.inner.x);\n    assert_eq(keys.ovpk_m.inner.y, deserialized.ovpk_m.inner.y);\n    assert_eq(keys.tpk_m.inner.x, deserialized.tpk_m.inner.x);\n    assert_eq(keys.tpk_m.inner.y, deserialized.tpk_m.inner.y);\n}\n"
     },
-    "317": {
+    "324": {
       "path": "/build-volume/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"
+      "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\n// Helper function to find the index of the first element in an array that satisfies a given predicate. If the element\n// is not found, the function returns N as the index.\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        // We check `index == N` to ensure that we only update the index if we haven't found a match yet.\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 where validate_array(array) returns true,\n// which ensures that:\n// 1. All elements before the first empty element are non-empty\n// 2. All elements after and including the first empty element are empty\n// 3. The array forms a contiguous sequence of non-empty elements followed by empty elements\npub fn array_length<T, let N: u32>(array: [T; N]) -> u32\nwhere\n    T: Empty + Eq,\n{\n    // We get the length by checking the index of the first empty element.\n\n    /// Safety: This is safe because we have validated the array (see function doc above) and the emptiness\n    /// of the element and non-emptiness of the previous element is checked below.\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]\nunconstrained fn find_index_greater_than_min() {\n    let values = [10, 20, 30, 40];\n    let min = 22;\n    let index = find_index_hint(values, |v: Field| min.lt(v));\n    assert_eq(index, 2);\n}\n\n#[test]\nunconstrained fn find_index_not_found() {\n    let values = [10, 20, 30, 40];\n    let min = 100;\n    let index = 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 concatenated = array_concat(array0, array1);\n    assert_eq(concatenated, [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"
     },
-    "320": {
+    "327": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/utils/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() as bool\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn finish(self) {\n        assert(self.offset == self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "325": {
+    "332": {
       "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"
     },
-    "329": {
+    "336": {
       "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"
     },
@@ -5903,7 +6078,7 @@
     },
     "62": {
       "path": "/build-volume/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"
+      "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\n        // Load auth witness\n        /// Safety: The witness is only used as a \"magical value\" that makes the signature verification below pass.\n        /// Hence it's safe.\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"
     },
     "63": {
       "path": "/build-volume/noir-projects/noir-contracts/contracts/schnorr_account_contract/src/public_key_note.nr",
@@ -5935,15 +6110,15 @@
     },
     "80": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/context/private_context.nr",
-      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n            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    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // 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        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store_array(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        // WARNING: This is insecure and should be temporary!\n        // The oracle hashes the arguments and returns a new args_hash.\n        // new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        // We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        // b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
+      "source": "use dep::protocol_types::debug_log::debug_log_format;\n\nuse crate::{\n    context::{inputs::PrivateContextInputs, returns_hash::ReturnsHash},\n    hash::{ArgsHasher, hash_args_array},\n    keys::constants::{NULLIFIER_INDEX, NUM_KEY_TYPES, OUTGOING_INDEX, sk_generators},\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        block_header::get_block_header_at,\n        call_private_function::call_private_function_internal,\n        enqueue_public_function_call::{\n            enqueue_public_function_call_internal, notify_set_min_revertible_side_effect_counter,\n            set_public_teardown_function_call_internal,\n        },\n        execution_cache,\n        key_validation_request::get_key_validation_request,\n        notes::{notify_created_nullifier, notify_nullified_note},\n    },\n};\nuse dep::protocol_types::{\n    abis::{\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        log::Log,\n        log_hash::LogHash,\n        max_block_number::MaxBlockNumber,\n        note_hash::NoteHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::PrivateLogData,\n        public_call_request::PublicCallRequest,\n        read_request::ReadRequest,\n        side_effect::Counted,\n        validation_requests::{KeyValidationRequest, KeyValidationRequestAndGenerator},\n    },\n    address::{AztecAddress, EthAddress},\n    block_header::BlockHeader,\n    constants::{\n        MAX_CONTRACT_CLASS_LOGS_PER_CALL, MAX_ENQUEUED_CALLS_PER_CALL,\n        MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NOTE_HASHES_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DISPATCH_SELECTOR,\n    },\n    messaging::l2_to_l1_message::L2ToL1Message,\n    traits::Empty,\n};\n\n// When finished, one can call .finish() to convert back to the abi\npub struct PrivateContext {\n    // docs:start:private-context\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub max_block_number: MaxBlockNumber,\n\n    pub note_hash_read_requests: BoundedVec<ReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL>,\n    pub nullifier_read_requests: BoundedVec<ReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n    key_validation_requests_and_generators: BoundedVec<KeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_CALL>,\n\n    pub note_hashes: BoundedVec<NoteHash, MAX_NOTE_HASHES_PER_CALL>,\n    pub nullifiers: BoundedVec<Nullifier, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<L2ToL1Message, MAX_L2_TO_L1_MSGS_PER_CALL>,\n    // docs:end:private-context\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub historical_header: BlockHeader,\n\n    pub private_logs: BoundedVec<PrivateLogData, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<LogHash, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    // Contains the last key validation request for each key type. This is used to cache the last request and avoid\n    // fetching the same request multiple times.\n    // The index of the array corresponds to the key type (0 nullifier, 1 incoming, 2 outgoing, 3 tagging).\n    pub last_key_validation_requests: [Option<KeyValidationRequest>; NUM_KEY_TYPES],\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            historical_header: inputs.historical_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n\n    pub fn msg_sender(self) -> AztecAddress {\n        self.inputs.call_context.msg_sender\n    }\n\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    pub fn push_note_hash(&mut self, note_hash: Field) {\n        self.note_hashes.push(NoteHash { value: note_hash, counter: self.next_counter() });\n\n        // WARNING(https://github.com/AztecProtocol/aztec-packages/issues/10558): if you delete this debug_log_format line, some tests fail.\n        debug_log_format(\n            \"Context.note_hashes, after pushing new note hash: {0}\",\n            self.note_hashes.storage().map(|nh: NoteHash| nh.value),\n        );\n    }\n\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(\n            Nullifier { value: nullifier, note_hash: 0, counter: self.next_counter() },\n        );\n    }\n\n    pub fn push_nullifier_for_note_hash(&mut self, nullifier: Field, nullified_note_hash: Field) {\n        let nullifier_counter = self.next_counter();\n        notify_nullified_note(nullifier, nullified_note_hash, nullifier_counter);\n        self.nullifiers.push(\n            Nullifier {\n                value: nullifier,\n                note_hash: nullified_note_hash,\n                counter: nullifier_counter,\n            },\n        );\n    }\n\n    // Returns the header of a block whose state is used during private execution (not the block the transaction is\n    // included in).\n    pub fn get_block_header(self) -> BlockHeader {\n        self.historical_header\n    }\n\n    // Returns the header of an arbitrary block whose block number is less than or equal to the block number\n    // of historical header.\n    pub fn get_block_header_at(self, block_number: u32) -> BlockHeader {\n        get_block_header_at(block_number, self)\n    }\n\n    pub fn set_return_hash(&mut self, returns_hasher: ArgsHasher) {\n        execution_cache::store(returns_hasher.fields);\n        self.return_hash = returns_hasher.hash();\n    }\n\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            max_block_number: self.max_block_number,\n            note_hash_read_requests: self.note_hash_read_requests.storage(),\n            nullifier_read_requests: self.nullifier_read_requests.storage(),\n            key_validation_requests_and_generators: self\n                .key_validation_requests_and_generators\n                .storage(),\n            note_hashes: self.note_hashes.storage(),\n            nullifiers: self.nullifiers.storage(),\n            private_call_requests: self.private_call_requests.storage(),\n            public_call_requests: self.public_call_requests.storage(),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: self.l2_to_l1_msgs.storage(),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: self.private_logs.storage(),\n            contract_class_logs_hashes: self.contract_class_logs_hashes.storage(),\n            historical_header: self.historical_header,\n            tx_context: self.inputs.tx_context,\n        }\n    }\n\n    pub fn set_as_fee_payer(&mut self) {\n        dep::protocol_types::debug_log::debug_log_format(\n            \"Setting {0} as fee payer\",\n            [self.this_address().to_field()],\n        );\n        self.is_fee_payer = true;\n    }\n\n    pub fn end_setup(&mut self) {\n        // dep::protocol_types::debug_log::debug_log_format(\n        //     \"Ending setup at counter {0}\",\n        //     [self.side_effect_counter as Field]\n        // );\n        self.min_revertible_side_effect_counter = self.side_effect_counter;\n        notify_set_min_revertible_side_effect_counter(self.min_revertible_side_effect_counter);\n    }\n\n    // docs:start:max-block-number\n    pub fn set_tx_max_block_number(&mut self, max_block_number: u32) {\n        // docs:end:max-block-number\n        self.max_block_number =\n            MaxBlockNumber::min_with_u32(self.max_block_number, max_block_number);\n    }\n\n    pub fn push_note_hash_read_request(&mut self, note_hash: Field) {\n        let side_effect = ReadRequest { value: note_hash, counter: self.next_counter() };\n        self.note_hash_read_requests.push(side_effect);\n    }\n\n    pub fn push_nullifier_read_request(&mut self, nullifier: Field) {\n        let request = ReadRequest { value: nullifier, counter: self.next_counter() };\n        self.nullifier_read_requests.push(request);\n    }\n\n    pub fn request_nsk_app(&mut self, npk_m_hash: Field) -> Field {\n        self.request_sk_app(npk_m_hash, NULLIFIER_INDEX)\n    }\n\n    pub fn request_ovsk_app(&mut self, ovpk_m_hash: Field) -> Field {\n        self.request_sk_app(ovpk_m_hash, OUTGOING_INDEX)\n    }\n\n    fn request_sk_app(&mut self, pk_m_hash: Field, key_index: Field) -> Field {\n        let cached_request =\n            self.last_key_validation_requests[key_index].unwrap_or(KeyValidationRequest::empty());\n\n        if cached_request.pk_m.hash() == pk_m_hash {\n            // We get a match so the cached request is the latest one\n            cached_request.sk_app\n        } else {\n            // We didn't get a match meaning the cached result is stale\n            // Typically we'd validate keys by showing that they are the preimage of `pk_m_hash`, but that'd require\n            // the oracle returning the master secret keys, which could cause malicious contracts to leak it or learn\n            // about secrets from other contracts. We therefore silo secret keys, and rely on the private kernel to\n            // validate that we siloed secret key corresponds to correct siloing of the master secret key that hashes\n            // to `pk_m_hash`.\n\n            /// Safety: Kernels verify that the key validation request is valid and below we verify that a request\n            /// for the correct public key has been received.\n            let request = unsafe { get_key_validation_request(pk_m_hash, key_index) };\n            assert_eq(request.pk_m.hash(), pk_m_hash, \"Obtained invalid key validation request\");\n\n            self.key_validation_requests_and_generators.push(\n                KeyValidationRequestAndGenerator {\n                    request,\n                    sk_app_generator: sk_generators[key_index],\n                },\n            );\n            self.last_key_validation_requests[key_index] = Option::some(request);\n            request.sk_app\n        }\n    }\n\n    // docs:start:context_message_portal\n    pub fn message_portal(&mut self, recipient: EthAddress, content: Field) {\n        // docs:end:context_message_portal\n        let message = L2ToL1Message { recipient, content, counter: self.next_counter() };\n        self.l2_to_l1_msgs.push(message);\n    }\n\n    // docs:start:context_consume_l1_to_l2_message\n    // docs:start:consume_l1_to_l2_message\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        // docs:end:context_consume_l1_to_l2_message\n        let nullifier = process_l1_to_l2_message(\n            self.historical_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n    // docs:end:consume_l1_to_l2_message\n\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter: 0, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn emit_raw_note_log(\n        &mut self,\n        log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS],\n        note_hash_counter: u32,\n    ) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: Log::new(log), note_hash_counter, counter };\n        self.private_logs.push(private_log);\n    }\n\n    pub fn call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_private_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) -> ReturnsHash {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_private_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) -> ReturnsHash {\n        self.call_private_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        /// Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        /// execution of the call (which means that end_side_effect_counter - start_side_effect_counter is\n        /// the number of side effects that took place), along with the hash of the return values. We validate these\n        /// by requesting a private kernel iteration in which the return values are constrained to hash\n        /// to `returns_hash` and the side effects counter to increment from start to end.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        // TODO (fees) figure out why this crashes the prover and enable it\n        // we need this in order to pay fees inside child call contexts\n        // assert(\n        //     (item.public_inputs.min_revertible_side_effect_counter == 0 as u32)\n        //     | (item.public_inputs.min_revertible_side_effect_counter\n        //         > self.min_revertible_side_effect_counter)\n        // );\n        // if item.public_inputs.min_revertible_side_effect_counter\n        //     > self.min_revertible_side_effect_counter {\n        //     self.min_revertible_side_effect_counter = item.public_inputs.min_revertible_side_effect_counter;\n        // }\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    pub fn call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn static_call_public_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.call_public_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    pub fn call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, false)\n    }\n\n    pub fn static_call_public_function_no_args(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n    ) {\n        self.call_public_function_with_args_hash(contract_address, function_selector, 0, true)\n    }\n\n    pub fn call_public_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            enqueue_public_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        // Public calls are rerouted through the dispatch function.\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        let call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    pub fn set_public_teardown_function<let ARGS_COUNT: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ARGS_COUNT],\n    ) {\n        let args_hash = hash_args_array(args);\n        execution_cache::store(args);\n        self.set_public_teardown_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            false,\n        )\n    }\n\n    pub fn set_public_teardown_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        /// Safety: TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Fix this.\n        /// WARNING: This is insecure and should be temporary!\n        /// The oracle hashes the arguments and returns a new args_hash.\n        /// new_args = [selector, ...old_args], so as to make it suitable to call the public dispatch function.\n        /// We don't validate or compute it in the circuit because a) it's harder to do with slices, and\n        /// b) this is only temporary.\n        let args_hash = unsafe {\n            set_public_teardown_function_call_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                counter,\n                is_static_call,\n            )\n        };\n\n        let function_selector = comptime { FunctionSelector::from_field(PUBLIC_DISPATCH_SELECTOR) };\n\n        self.public_teardown_call_request = PublicCallRequest {\n            msg_sender: self.this_address(),\n            contract_address,\n            function_selector,\n            is_static_call,\n            args_hash,\n        };\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            max_block_number: MaxBlockNumber::empty(),\n            note_hash_read_requests: BoundedVec::new(),\n            nullifier_read_requests: BoundedVec::new(),\n            key_validation_requests_and_generators: BoundedVec::new(),\n            note_hashes: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            historical_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            last_key_validation_requests: [Option::none(); NUM_KEY_TYPES],\n        }\n    }\n}\n"
     },
     "83": {
       "path": "/build-volume/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"
+      "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::Packable};\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: Packable<N>,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n}\n"
     },
     "86": {
       "path": "/build-volume/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\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"
+      "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\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        /// Safety:   Unconstrained logs have both their content and encryption unconstrained - it could occur that\n        /// the 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\n        /// have more than one log and removes all of the matching ones, so all a malicious sender could do is\n        /// either: cause for the log to be deleted when it shouldn't have (which is fine - they can already make\n        /// the content be whatever), or cause for the log to not be deleted when it should have (which is also fine\n        /// - it'll be a log for a note that doesn't exist).\n        ///   It's important here that we do not return the log from this function to the app, otherwise it could\n        /// try to do stuff with it and then that might 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"
     },
     "87": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/encrypted_logs/header.nr",
@@ -5951,11 +6126,11 @@
     },
     "89": {
       "path": "/build-volume/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    // Nargo seems to struggle with realizing that `offset` is a constant at this point.\n    // We then redefine it in terms of the assertion above to give nargo a hint.\n    let offset = M - incoming_body_ciphertext.len();\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; P + 16 - P % 16] {\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"
+      "source": "use dep::protocol_types::{\n    address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS, hash::poseidon2_hash,\n    point::Point, public_keys::AddressPoint, scalar::Scalar, utils::arrays::array_concat,\n};\nuse std::{\n    aes128::aes128_encrypt, embedded_curve_ops::fixed_base_scalar_mul as derive_public_key,\n    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    /// Safety: We assume that the sender wants for the recipient to find the tagged note, and therefore that they\n    /// will cooperate and use the correct tag. Usage of a bad tag will result in the recipient not being able to\n    /// find the note 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\n// We return [Field; 1 + (M + 30) / 31], where M is the byte length of output of encryption because\n// each field (apart from the tag) contains 31 bytes so the length in fields is computed as ceil(setup_log_byte_length / 31)\n// --> we achieve rounding by adding 30 and then dividing without remainder, then add one for the 32 byte tag\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) -> [Field; 1 + (M + 30) / 31] {\n    let extended_plaintext: [u8; P + PLAINTEXT_LENGTH_SIZE] =\n        extend_private_log_plaintext(plaintext);\n    let encrypted: [u8; M] = compute_encrypted_log(contract_address, recipient, extended_plaintext);\n\n    /// Safety: We assume that the sender wants for the recipient to find the tagged note, and therefore that they\n    /// will cooperate and use the correct tag. Usage of a bad tag will result in the recipient not being able to\n    /// find the note 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    let siloed_tag = poseidon2_hash([contract_address.to_field(), tag]);\n\n    array_concat([siloed_tag], bytes_to_fields(encrypted))\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; HEADER_SIZE] =\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    // Nargo seems to struggle with realizing that `offset` is a constant at this point.\n    // We then redefine it in terms of the assertion above to give nargo a hint.\n    let offset = M - incoming_body_ciphertext.len();\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    /// Safety: A malicious sender could reveal the whole contents of the encrypted log so trusting it to set\n    /// a random padding in plaintext is fine.\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\nfn generate_ephemeral_key_pair() -> (Scalar, Point) {\n    // @todo Need to draw randomness from the full domain of Fq not only Fr\n\n    /// Safety: We use the randomness to preserve the privacy of both the sender and recipient via encryption, so\n    /// a malicious sender could use non-random values to reveal the plaintext. But they already know it themselves\n    /// anyway, and so the recipient already trusts them to not disclose this information. We can therefore assume\n    /// that the sender will 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; P + 16 - P % 16] {\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"
     },
     "93": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/hash.nr",
-      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_unencrypted_log_hash<let N: u32>(\n    contract_address: AztecAddress,\n    log: [u8; N],\n) -> Field {\n    let mut hash_bytes = [0; N + 36];\n    // Address is converted to 32 bytes in ts\n    let address_bytes: [u8; 32] = contract_address.to_field().to_be_bytes();\n    for i in 0..32 {\n        hash_bytes[i] = address_bytes[i];\n    }\n    let len_bytes: [u8; 4] = (N as Field).to_be_bytes();\n    for i in 0..4 {\n        hash_bytes[32 + i] = len_bytes[i];\n    }\n    for i in 0..N {\n        hash_bytes[36 + i] = log[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_array() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = [\n        0x20660de09f35f876e3e69d227b2a35166ad05f09d82d06366ec9b6f65a51fec2,\n        0x1b52bfe3b8689761916f76dc3d38aa8810860db325cd39ca611eed980091f01c,\n        0x2e559c4045c378a56ad13b9edb1e8de4e7ad3b3aa35cc7ba9ec77f7a68fa43a4,\n        0x25d0f689c4a4178a29d59306f2675824d19be6d25e44fa03b03f49c263053dd2,\n        0x2d513a722d6f352dc0961f156afdc5e31495b9f0e35cb069261a8e55e2df67fd,\n    ];\n    let serialized_log = arr_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0095b2d17ab72f4b27a341f7ac63e49ec73935ae8c9181a0ac02023eb12f3284);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_addr() {\n    let contract_address = AztecAddress::from_field(\n        0x233a3e0df23b2b15b324194cb4a151f26c0b7333250781d34cc269d85dc334c6,\n    );\n    let log = AztecAddress::from_field(\n        0x26aa302d4715fd8a687453cb26d616b0768027bd54bcae56b09d908ecd9f8303,\n    );\n    let serialized_log: [u8; 32] = log.to_field().to_be_bytes();\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0083ab647dfb26e7ddee90a0f4209d049d4660cab42000c544b986aaa84c55a3);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"dummy\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x00629e88ebd6374f44aa6cfe07e251ecf07213ebc7267e8f6b578ae57ffd6c20);\n}\n\n#[test]\nunconstrained fn compute_unenc_log_hash_longer_str() {\n    let contract_address = AztecAddress::from_field(\n        0x1b401e1146c5c507962287065c81f0ef7590adae3802c533d7549d6bf0a41bd8,\n    );\n    let log = \"Hello this is a string\";\n    let serialized_log = str_to_be_bytes_arr(log);\n    let hash = compute_unencrypted_log_hash(contract_address, serialized_log);\n    assert(hash == 0x0098637962f7d34fa202b7ffad8a07a238c5d1fd897b82a108f7f467fa73b841);\n}\n"
+      "source": "use crate::utils::to_bytes::{arr_to_be_bytes_arr, str_to_be_bytes_arr};\nuse dep::protocol_types::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        GENERATOR_INDEX__FUNCTION_ARGS, GENERATOR_INDEX__MESSAGE_NULLIFIER,\n        GENERATOR_INDEX__SECRET_HASH,\n    },\n    hash::{poseidon2_hash_with_separator, poseidon2_hash_with_separator_slice, sha256_to_field},\n    point::Point,\n    traits::Hash,\n};\n\npub use dep::protocol_types::hash::{compute_siloed_nullifier, pedersen_hash};\n\npub fn pedersen_commitment<let N: u32>(inputs: [Field; N], hash_index: u32) -> Point {\n    std::hash::pedersen_commitment_with_separator(inputs, hash_index)\n}\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], GENERATOR_INDEX__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], GENERATOR_INDEX__MESSAGE_NULLIFIER)\n}\n\npub struct ArgsHasher {\n    pub fields: [Field],\n}\n\nimpl Hash for ArgsHasher {\n    fn hash(self) -> Field {\n        hash_args(self.fields)\n    }\n}\n\nimpl ArgsHasher {\n    pub fn new() -> Self {\n        Self { fields: [] }\n    }\n\n    pub fn add(&mut self, field: Field) {\n        self.fields = self.fields.push_back(field);\n    }\n\n    pub fn add_multiple<let N: u32>(&mut self, fields: [Field; N]) {\n        for i in 0..N {\n            self.fields = self.fields.push_back(fields[i]);\n        }\n    }\n}\n\npub fn hash_args_array<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\npub fn hash_args(args: [Field]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator_slice(args, GENERATOR_INDEX__FUNCTION_ARGS)\n    }\n}\n\n#[test]\nunconstrained fn compute_var_args_hash() {\n    let mut input = ArgsHasher::new();\n    for i in 0..100 {\n        input.add(i as Field);\n    }\n    let hash = input.hash();\n    dep::std::println(hash);\n    assert(hash == 0x19b0d74feb06ebde19edd85a28986c97063e84b3b351a8b666c7cac963ce655f);\n}\n"
     }
   }
 }