@aztec/accounts 0.76.1 → 0.76.2

package/artifacts/EcdsaRAccount.json

@@ -4,11 +4,9 @@
   "name": "EcdsaRAccount",
   "functions": [
     {
-      "name": "entrypoint",
-      "is_unconstrained": false,
-      "custom_attributes": [
-        "private"
-      ],
+      "name": "compute_note_hash_and_optionally_a_nullifier",
+      "is_unconstrained": true,
+      "custom_attributes": [],
       "abi": {
         "error_types": {
           "11091894166229312484": {
@@ -16,6 +14,110 @@
             "item_types": [],
             "length": 20
           },
+          "16761564377371454734": {
+            "error_kind": "string",
+            "string": "Array index out of bounds"
+          },
+          "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": {
+            "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": "packed_note_content",
+            "type": {
+              "kind": "array",
+              "length": 5,
+              "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"
+      ]
+    },
+    {
+      "name": "constructor",
+      "is_unconstrained": false,
+      "custom_attributes": [
+        "private",
+        "initializer"
+      ],
+      "abi": {
+        "error_types": {
           "14514982005979867414": {
             "error_kind": "string",
             "string": "attempt to bit-shift with overflow"
@@ -24,14 +126,22 @@
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
-          "1705275289401561847": {
+          "17618083556256589634": {
             "error_kind": "string",
-            "string": "Mismatch note header storage slot."
+            "string": "Initialization hash does not match"
           },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
+          "2233873454491509486": {
+            "error_kind": "string",
+            "string": "Initializer address is not the contract deployer"
+          },
+          "2709101749560550278": {
+            "error_kind": "string",
+            "string": "Cannot serialize point at infinity as bytes."
+          },
           "2920182694213909827": {
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
@@ -40,13 +150,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "5727012404371710682": {
-            "error_kind": "string",
-            "string": "push out of bounds"
-          },
-          "6869395374906889440": {
+          "6485997221020871071": {
             "error_kind": "string",
-            "string": "Mismatch note header contract address."
+            "string": "call to assert_max_bit_size"
           },
           "7233212735005103307": {
             "error_kind": "string",
@@ -536,173 +642,28 @@
             "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",
+            "name": "signing_pub_key_x",
             "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"
+              "kind": "array",
+              "length": 32,
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 8
+              }
             },
             "visibility": "private"
           },
           {
-            "name": "cancellable",
+            "name": "signing_pub_key_y",
             "type": {
-              "kind": "boolean"
+              "kind": "array",
+              "length": 32,
+              "type": {
+                "kind": "integer",
+                "sign": "unsigned",
+                "width": 8
+              }
             },
             "visibility": "private"
           }
@@ -1812,32 +1773,33 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "bytecode": "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",
+      "debug_symbols": "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",
       "brillig_names": [
-        "get_note_internal",
+        "get_contract_instance_internal",
         "decompose_hint",
-        "get_auth_witness",
+        "lte_hint",
+        "notify_created_nullifier_oracle_wrapper",
+        "notify_created_note_oracle_wrapper",
+        "debug_log_oracle_wrapper",
+        "random",
+        "field_less_than",
         "build_msg_block",
         "attach_len_to_msg_block",
-        "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",
+        "get_random_bytes",
+        "get_app_tag_as_sender",
+        "increment_app_tagging_secret_index_as_sender_wrapper",
         "directive_integer_quotient",
+        "directive_invert",
         "directive_to_radix"
       ],
-      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAABlqFzI5+d7YH06UQ/2zivWCIAE7+gTiwHg5SvHqtBn4I6252vn/w15ruKenFQSCCN84wpEGWxPztKt7kZ3aTbgP4ouAcqYUW7U0JBSlPafew7JWIFxLJQwSs0GnpszfswEQ3wTV/+cY9hXVZ1hz1QSgP0CNyYz68BvsOyEiLCB+IWSZYedT/QBUwBm0C9Ou4Z0UC1Zl2D0wUIyfvxAlzZAETF99z7pinGt/egNk43K2GqfNTvvgEDbEDAToh2QOPCG51eqcpGvs9I0Ud8ndcu0ITj4Ct7NzaUkwK6G+/MYMHqwQ2jXt8dzYvMRyevqZqILXeT6ZMNSsBQr3GypeyjYJprKGVhcHl83sXqp/UZeiUtIdMibYcW+TJdo39i9Z6hhr6J/4jz7kgFlsBwtuFJ80bVGYagW4WRuOzcBy/nnbE6AVvGbSJdYOeE1KqiJGVgFcKLgtMntQV1FX3CU4ACALMeMsXTTIvdYy48KQPIL3f4QpcxwJ1x9gHQ+LEhYWEwRWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQXi1+6ZLcvOFtO15wDTn30vfLS9qc1guKe94QIguOiURAIZszrzdK3fEz7f/kdvq2Sr9pQoZLZWl3HMYyqMxGrLGjfzrGH0+dGSuHmJ7Y3qsezuklQ0Y1sTOtTe4CJBZgfDmx0vxisEJ8//1A6PY8FltNVVzwJnE+6DOmYToOA3CYcZUhYAMuXR+aqvBf+tIVukPJ6XqWF/s1ukk97kPLyI/kcPDN3wRKOg7yZYizS6WAFF88Qo25hLvZHK9CGjcIQK/fcT6JpeBDBvVHvkOlrNj+BVPhI8dl99qu/mCqEWARlIVWO8yCdrnL3rpAIs+nt7UfOapFA6eWvavyJp3OqHLiIOkysYPsd+3B+l1cnnhslS/GuyGlR8UDB2nsma7Is5IOVWZRIHvaFIXB3tpRhE6seCGca1wuDghU2DmTbnh+IdbZp6acFsWiFiEsupqdJwccch7UJ16FhTTrKJAViBty2GGkguhQ41jsCQRD2U4wmpSCLzji8W+WX4eR+vRYdrT9OeARL9hl8vT43b2eXKhxyUOWHIsuXUpyFOu2kbCQ63qqKYxzfe8JYYVDbotaKSUEvRdYe9PqKE0NyZ/neLplV8cxGg9FGo+sJWi7Bd9aYsij9j21aMc6CcXDR2/IIcS/A0i5vpElCDYwJaL8DU4jj6t4QCDwOP5ZBU8mhDTBXM6n8jIfTLg9OFjGo8EMWaWBNQ1if0JtS60ChiYGTFEsrLwuuXcvRZoUECbnDoU7udSxbF3NZ2FN4oiZVB1IrIewgVJKS3BipGPxD1L+cgnT982boJrwzlKkd8HaZNxZFyfyjOowabRgkKKbnGzpF9YxMx7gfP2f4MKlIHk99E0V6Rr+vBCWsWOyVw5PvkxgT/cLEKParoVeGRVSnpeskDjAnu8S6tlnJgmIpDi0lovcOCCUtlFjOz04ejNOMkiCOhrjFw+egzRpu48fXI8KeUDrvIqUcTUQ5JAIMxvpVIXxT28QWmSonftLMU/mViapF84MYGLDYyhrthyV/NSQpIvfUTeL7fmOr/5wxXJU/WcRJ82GWbILbZFP6E0zIwBppIF0Vlsz4PIeILBbRM16AzkGfV+Ola3V/pSmI2/6wELT+d1mJIKDVYiN5wagHAZ2x8HZZX0TNxifiD2leQxMFajx7GPTQ2uZUTJGifQuzduzpg3v+z/RoCfWALaz4+gCy8lbuhHzgp0QqmLVqhnczt19QGhN7fQHP2NuJUfxLB/MMmhuW6NUCwgUR/1tYNfM+bM5OovQsyQDRQ+PcljAQKKrcdTbI9eDrQvsasaNRrFtBnahWobyJtJQyGFL3ywB2F2gJnOHRVG/Bxdk/CjtqPTJfX89l3gZv58BueZXXAWszdW7ZGSCfTW9caTziEkHLasnPFO6c8gr5yfNxJuoDCFNT8Uqdqwc8wZO5i0exkJD8MC6mlBb31PhzCo6IGixElClrYoH2m3nzLWCk4KRWyi/4b2MYc/5sNwYgZexALZvnOSgG1Hp5HrdnsKSWDU1eyfbWDVjc/mOAKqjLEKAOnnzonrwmT9xpaUeQlWnS6Nx8yrFsTuHBSbQKhxl7vCDtQq4E8NraFolUJHckASv9dX/hNA/z8wVI4XPFTy4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAhx/Eay0wPb/F5PLwUGNHcUsh09kb0fwvLZ/siXcYrcgD84nVoPXdzRZKSZoiiYeCJguj6hbtGo1WPr2Xw/cd0wPy7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
+      "verification_key": "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"
     },
     {
-      "name": "verify_private_authwit",
+      "name": "entrypoint",
       "is_unconstrained": false,
       "custom_attributes": [
-        "private",
-        "noinitcheck",
-        "view"
+        "private"
       ],
       "abi": {
         "error_types": {
@@ -1862,22 +1824,18 @@
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "19458536156181958": {
-            "error_kind": "string",
-            "string": "Function verify_private_authwit can only be called statically"
-          },
           "2920182694213909827": {
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
           },
-          "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."
@@ -2370,9 +2328,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"
           }
@@ -3482,50 +3604,39 @@
           "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",
         "build_msg_block",
         "attach_len_to_msg_block",
-        "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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"
-    },
-    {
-      "name": "sync_notes",
-      "is_unconstrained": true,
-      "custom_attributes": [],
-      "abi": {
-        "error_types": {
-          "17843811134343075018": {
-            "error_kind": "string",
-            "string": "Stack too deep"
-          }
-        },
-        "parameters": [],
-        "return_type": null
-      },
-      "bytecode": "H4sIAAAAAAAA/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
-      "debug_symbols": "bY/RCoMwDEX/Jc99aLrppr8iQ6pGKZRWah0M8d8Xxybd5sslN5xcchfoqJmH2rjeT1BWC1jf6mi8Y7esAppgrDVDna5BboKnFz+N2m12ijpEKDG7CCDX8ZRnfN8bS1DmahX/qESpPrBEVew4nq/HfIE7r1B+8beV7V0HoxtL7+f72bVJl/gY6afWGHxL3RxoK5h0Y60wE0pyLEc/AQ==",
-      "brillig_names": [
-        "sync_notes"
-      ]
+      "verification_key": "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"
     },
     {
-      "name": "constructor",
+      "name": "verify_private_authwit",
       "is_unconstrained": false,
       "custom_attributes": [
         "private",
-        "initializer"
+        "noinitcheck",
+        "view"
       ],
       "abi": {
         "error_types": {
+          "11091894166229312484": {
+            "error_kind": "fmtstring",
+            "item_types": [],
+            "length": 20
+          },
           "14514982005979867414": {
             "error_kind": "string",
             "string": "attempt to bit-shift with overflow"
@@ -3534,33 +3645,33 @@
             "error_kind": "string",
             "string": "Array index out of bounds"
           },
-          "17618083556256589634": {
+          "1705275289401561847": {
             "error_kind": "string",
-            "string": "Initialization hash does not match"
+            "string": "Mismatch note header storage slot."
           },
           "17843811134343075018": {
             "error_kind": "string",
             "string": "Stack too deep"
           },
-          "2233873454491509486": {
-            "error_kind": "string",
-            "string": "Initializer address is not the contract deployer"
-          },
-          "2709101749560550278": {
+          "19458536156181958": {
             "error_kind": "string",
-            "string": "Cannot serialize point at infinity as bytes."
+            "string": "Function verify_private_authwit can only be called statically"
           },
           "2920182694213909827": {
             "error_kind": "string",
             "string": "attempt to subtract with overflow"
           },
+          "4939791462094160055": {
+            "error_kind": "string",
+            "string": "Message not authorized by account"
+          },
           "5019202896831570965": {
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "6485997221020871071": {
+          "6869395374906889440": {
             "error_kind": "string",
-            "string": "call to assert_max_bit_size"
+            "string": "Mismatch note header contract address."
           },
           "7233212735005103307": {
             "error_kind": "string",
@@ -4050,28 +4161,9 @@
             "visibility": "private"
           },
           {
-            "name": "signing_pub_key_x",
-            "type": {
-              "kind": "array",
-              "length": 32,
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 8
-              }
-            },
-            "visibility": "private"
-          },
-          {
-            "name": "signing_pub_key_y",
+            "name": "inner_hash",
             "type": {
-              "kind": "array",
-              "length": 32,
-              "type": {
-                "kind": "integer",
-                "sign": "unsigned",
-                "width": 8
-              }
+              "kind": "field"
             },
             "visibility": "private"
           }
@@ -5181,133 +5273,19 @@
           "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_contract_instance_internal",
-        "decompose_hint",
-        "lte_hint",
-        "notify_created_nullifier_oracle_wrapper",
-        "notify_created_note_oracle_wrapper",
-        "debug_log_oracle_wrapper",
-        "random",
-        "field_less_than",
+        "get_note_internal",
+        "get_auth_witness",
         "build_msg_block",
         "attach_len_to_msg_block",
-        "get_random_bytes",
-        "get_app_tag_as_sender",
-        "increment_app_tagging_secret_index_as_sender_wrapper",
-        "directive_integer_quotient",
+        "store_in_execution_cache_oracle_wrapper",
         "directive_invert",
+        "directive_integer_quotient",
         "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"
-          },
-          "2920182694213909827": {
-            "error_kind": "string",
-            "string": "attempt to subtract with overflow"
-          },
-          "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": "packed_note_content",
-            "type": {
-              "kind": "array",
-              "length": 5,
-              "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"
-      ]
+      "verification_key": "AAAAAAAQAAAAAAAAAAAAFAAAAAAAAAAQAAAAAAADKLEBAAAAAAAAAAEAAAACAAAAAwAAAAQAAAAFAAAABgAAAAcAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAAAAAAAAAAAjpV/oKJI+Bar9/t7VHr1GTt8VE+HPB0sZeXqwf3IypAABw4e9Y8DYnakX1BIV1NmBwcriTcJFYF2eVCcHaB7gnxOzTq4mUNGNAcyDp89zQGxiWB3KiWHfziMEt7daX8h07pMiTSAK6w3bv/o1emWw52Fiv4+5AP/Xz5LYc3/uCFu0VoA9Ei7+uXh7sRKVpwYeBp1u7wce1q7+kDaUAbBMCL9XS00G//bbeDs1tORFNSjNcIdK9JLYZF38fIFJD9BlTAUjscTrcmrjCR2/mMv+jyxyQl5VHzmxRiog25JXEJjpUF+OQzal4dzlpb3mdUBJ5os6nhQ0gPyKLi/fyYZkLGvWyelSRfLL9N48m3pqv0aRhI9PWvWqLjER8rYKtWBOlMKUSCBjOcyi9S1WJT8lmCWDhso7iYHmYJ3e1Hce4Dwt2ZacUyg0Nd7M5qhlz2qksqvTFyjR98mQOiJktyPgguNuoaf/7jJ3gG6N4lEguVhauRT6HlB23V3yzBkg7TQRWu3AbWwtGO7zwxP5xkFUjk9CVM+GyAEvYTp+KU6iPA4D05rswR3a/1Psi4gmHdBVkgemj+PCR0w2xADptqrQXi1+6ZLcvOFtO15wDTn30vfLS9qc1guKe94QIguOiURAIZszrzdK3fEz7f/kdvq2Sr9pQoZLZWl3HMYyqMxGrGbTunPwgLQzcHW85t5UtfObmxdkRFRuQt92FvFWqyQYswm0cXv095qPhL2XwMxWhH1O6Ka/tZQl/bt25N9Cg3CsCjv9i8qCDVuqxKMX9yJZ6wC3O5mePhTkCw2gpGw5TDOFthltXseMAJ8WkPfSql5viZ7P2HXpAlsnHzLpYPEcAph3qx2s3DKT0L3OmZct1qevcWM1L34r35/z/o21bcS5ZeJ8Nnbs/Fa3lOEt4SQ2x2DN5xzvkESPev8iMn8jWGnwgOcVYGsdHVr+xzBJUUFfvF90Z4M68X81fkg9kUQcBHZjP7UtnnWQtEYUA+EjrBA4TAfXv5EfwIHPAwvPlJigqi7NFxjweGMCclYXST/LDa4Nw6l9QCixUorH3NZwHF1fLSGSaWxF1sOqpeoyQ6s5Pj6df1nzYKL3Fi2Ld7q8u3r0pRBr1wIu9Fhc7gHxJC9mE09UucYFpX9x1UkAEPyrx9UWrh4sOz3ioA+yLbvuwbXOfIYnbOGxY067C0o5HGVF3yxgZbZyf7eIugamfIc+pj0ATlZwwHEw8MLGZW6EM7m56Mm1UgbtKc/i+3YSxazCSmx41GV7FdehxklgMMQd2UYtA2eywEQ2Dfo4LdwIiRcrlbwsGaCHeaqdaPsNkDaFqw8Xl+P/fwC/xasj8htISq7FaKpE5wIPT98kwe0oP3atY85C2oxnrGWASBbY3UrSLRGJzv2idIpnE1PQ2JCssLUKniZ8PxMaqZYEciydinu7oIAddRh6ORWHS9fGYLfOgW8zFV1ijDWoa/7ZTBDDRb6clPbqwcupHfx2GHswJi3AujhFHa5va6IAuW+a0yqRh4B2aPBtCVV/ZyFux+QnZEVQsVtBbRNEKOaigBfjRpP3GSzwYvj3Xbu7qG5GFAqkpj1FaM6AuRugIP0ICaobFJBn4x03CMO9rkS/e5okVuKMNH4lhpE+jCf+fUpMvfpBFTdjCIGtk8oSBnT9Htwd8PF4YiK6SPdzReKis14qUSqSKa0BKrQEeFUHNAe7IF66o/gEw32zPMh2FB0VaCkbqEbJ4pE4T1kPnRMTTTXsdgBoRSDA3EAAhDm/Sdj26Y+QkEg6veb32LkiFf9g4ogUizvhFO2HA0ncKqB4T/Zz7x5JiP2yoci9cZhc4SlTEDy8zN8OU9c7j7fzgj/lK0XqX2YLKxMRk1oXf0Odscl8QKKrcdTbI9eDrQvsasaNRrFtBnahWobyJtJQyGFL3ywB2F2gJnOHRVG/Bxdk/CjtqPTJfX89l3gZv58BueZXXAWszdW7ZGSCfTW9caTziEkHLasnPFO6c8gr5yfNxJuoDCFNT8Uqdqwc8wZO5i0exkJD8MC6mlBb31PhzCo6IGixElClrYoH2m3nzLWCk4KRWyi/4b2MYc/5sNwYgZexALZvnOSgG1Hp5HrdnsKSWDU1eyfbWDVjc/mOAKqjLEKAOnnzonrwmT9xpaUeQlWnS6Nx8yrFsTuHBSbQKhxl7vCDtQq4E8NraFolUJHckASv9dX/hNA/z8wVI4XPFTy4NAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAiNPwcevwZDCQFO1WKwWO8/xNQ1gFMpgmbLUETVI4iiCCOudM3XsBgkZRKgC6N0egdpIFDJ+3zMarrS1Ocjwgb0Py7+dPPQCuqPu2l8Knkm1werJWyZMMC3IVObyLXMw3yg+39qJyUgFl/CzRC6XUt751Y/Ckgg2GUJh97Fj/vuvHViqYcZK1SIEPXnEgCIZ5Vuhl1Gt/mw2Mk0/tsLaCYktfBipPD2uWICfqu7GqGp49LO8YfGdbnBpNZu/R+f5Bw=="
     },
     {
       "name": "process_log",
@@ -5462,11 +5440,31 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
-      "debug_symbols": "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",
+      "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/7WTyw7CIBBFqcUo0sTEx39MU0y7dOHafyCtLHVRN+766dZkJkyI0QVwEzJMgMNcHoXwKjBKESGCHDEqjAs2Xs7tjDnEqVbBvin5HRijvvhLWH+jkFnk4QPxM50/rJBzmTyfe6F913PTrF8J/z5y+af7y+l//8OzRq9bzCvh/8P4uvfXx/M2ij/SbJGc0ptoOwAqvkT+EvmhJBvn8w+Yb4Svj6KMqNO1tnaNdfZkh8H0dhfwP+KH/QbzqHp4zgQAAA==",
+      "debug_symbols": "bY/RCoMwDEX/Jc99aLqp6K/IkKpRCqWVWgdD/PfFsUm3+XLJDSeX3BV6apexMW7wM1T1CtZ3Ohrv2K2bgDYYa83YpGuQu+Dlxc+Tdrudow4RKswKAeR6nvKM7wdjCapcbeIflSjVB5aoygPHa3HOl3jwCuUXf9vY3nUwurX0fn5YXJd0iY+JfmpNwXfUL4H2gkk31hozoSTHcvQT",
+      "brillig_names": [
+        "sync_notes"
+      ]
     }
   ],
   "outputs": {
@@ -5602,6 +5600,45 @@
     },
     "structs": {
       "functions": [
+        {
+          "fields": [
+            {
+              "name": "parameters",
+              "type": {
+                "fields": [
+                  {
+                    "name": "signing_pub_key_x",
+                    "type": {
+                      "kind": "array",
+                      "length": 32,
+                      "type": {
+                        "kind": "integer",
+                        "sign": "unsigned",
+                        "width": 8
+                      }
+                    }
+                  },
+                  {
+                    "name": "signing_pub_key_y",
+                    "type": {
+                      "kind": "array",
+                      "length": 32,
+                      "type": {
+                        "kind": "integer",
+                        "sign": "unsigned",
+                        "width": 8
+                      }
+                    }
+                  }
+                ],
+                "kind": "struct",
+                "path": "EcdsaRAccount::constructor_parameters"
+              }
+            }
+          ],
+          "kind": "struct",
+          "path": "EcdsaRAccount::constructor_abi"
+        },
         {
           "fields": [
             {
@@ -5811,127 +5848,88 @@
           ],
           "kind": "struct",
           "path": "EcdsaRAccount::verify_private_authwit_abi"
-        },
-        {
-          "fields": [
-            {
-              "name": "parameters",
-              "type": {
-                "fields": [
-                  {
-                    "name": "signing_pub_key_x",
-                    "type": {
-                      "kind": "array",
-                      "length": 32,
-                      "type": {
-                        "kind": "integer",
-                        "sign": "unsigned",
-                        "width": 8
-                      }
-                    }
-                  },
-                  {
-                    "name": "signing_pub_key_y",
-                    "type": {
-                      "kind": "array",
-                      "length": 32,
-                      "type": {
-                        "kind": "integer",
-                        "sign": "unsigned",
-                        "width": 8
-                      }
-                    }
-                  }
-                ],
-                "kind": "struct",
-                "path": "EcdsaRAccount::constructor_parameters"
-              }
-            }
-          ],
-          "kind": "struct",
-          "path": "EcdsaRAccount::constructor_abi"
         }
       ]
     }
   },
   "file_map": {
-    "104": {
+    "103": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/keys/ecdh_shared_secret.nr",
       "source": "use dep::protocol_types::{\n    address::aztec_address::AztecAddress, point::Point, scalar::Scalar, traits::FromField,\n};\nuse std::embedded_curve_ops::multi_scalar_mul;\n\n/// Computes a standard ecdh shared secret: [secret] * public_key = shared_secret.\n/// The input secret is known only to one party. The output shared secret is derivable\n/// by both parties, through this function.\n/// E.g.:\n/// Epk = esk * G // ephemeral keypair\n/// Pk = sk * G // recipient keypair\n/// Shared secret S = esk * Pk = sk * Epk // see how this function can be called with two different sets of inputs, depending on which secret the caller knows (either esk or sk)?\n// See also: https://en.wikipedia.org/wiki/Elliptic-curve_Diffie%E2%80%93Hellman\npub fn derive_ecdh_shared_secret(secret: Scalar, public_key: Point) -> Point {\n    let shared_secret = multi_scalar_mul([public_key], [secret]);\n    shared_secret\n}\n\n/// Computes a standard ecdh shared secret using the address public key of the given address:\n/// [ephemeral_secret] * recipient_address_public_key = shared_secret.\n/// The intention is that the _creator_ of a shared secret would call this function,\n/// given the address of their intended recipient.\npub fn derive_ecdh_shared_secret_using_aztec_address(\n    ephemeral_secret: Scalar,\n    recipient_address: AztecAddress,\n) -> Point {\n    derive_ecdh_shared_secret(ephemeral_secret, recipient_address.to_address_point().inner)\n}\n\n#[test]\nunconstrained fn test_consistency_with_typescript() {\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 shared_secret = derive_ecdh_shared_secret(secret, point);\n\n    // This is just pasted from a test run.\n    // The original typescript code from which this could be generated seems to have been deleted by someone, and soon the typescript code for encryption and decryption won't be needed, so this will have to do.\n    let hard_coded_shared_secret = Point {\n        x: 0x15d55a5b3b2caa6a6207f313f05c5113deba5da9927d6421bcaa164822b911bc,\n        y: 0x0974c3d0825031ae933243d653ebb1a0b08b90ee7f228f94c5c74739ea3c871e,\n        is_infinite: false,\n    };\n    assert_eq(shared_secret, hard_coded_shared_secret);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_in_both_directions() {\n    let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n    let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n    let pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n    let pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n    let shared_secret = derive_ecdh_shared_secret(secret_a, pk_b);\n    let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n    assert_eq(shared_secret, shared_secret_alt);\n}\n\n#[test]\nunconstrained fn test_shared_secret_computation_from_address_in_both_directions() {\n    let secret_a = Scalar { lo: 0x1234, hi: 0x2345 };\n    let secret_b = Scalar { lo: 0x3456, hi: 0x4567 };\n\n    let mut pk_a = std::embedded_curve_ops::fixed_base_scalar_mul(secret_a);\n    let mut pk_b = std::embedded_curve_ops::fixed_base_scalar_mul(secret_b);\n\n    let address_b = AztecAddress::from_field(pk_b.x);\n\n    // We were lazy in deriving the secret keys, and didn't check the resulting y-coordinates\n    // of the pk_a or pk_b to be less than half the field modulus.\n    // If needed, we negate the pk's so that they yield valid address points.\n    // (We could also have negated the secrets, but there's no negate method for\n    // EmbeddedCurvesScalar).\n    pk_a = if (AztecAddress::from_field(pk_a.x).to_address_point().inner == pk_a) {\n        pk_a\n    } else {\n        pk_a.neg()\n    };\n    pk_b = if (address_b.to_address_point().inner == pk_b) {\n        pk_b\n    } else {\n        pk_b.neg()\n    };\n\n    let shared_secret = derive_ecdh_shared_secret_using_aztec_address(secret_a, address_b);\n    let shared_secret_alt = derive_ecdh_shared_secret(secret_b, pk_a);\n\n    assert_eq(shared_secret, shared_secret_alt);\n}\n"
     },
-    "105": {
+    "104": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/keys/ephemeral.nr",
       "source": "use std::{\n    embedded_curve_ops::fixed_base_scalar_mul, field::bn254::decompose,\n    hash::from_field_unsafe as fr_to_fq_unsafe,\n};\n\nuse dep::protocol_types::{point::Point, scalar::Scalar};\n\nuse crate::oracle::random::random;\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\npub fn 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 = fixed_base_scalar_mul(eph_sk);\n\n    (eph_sk, eph_pk)\n}\n"
     },
-    "106": {
+    "105": {
       "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    /// 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"
     },
-    "112": {
+    "111": {
       "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"
     },
-    "121": {
+    "120": {
       "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/// |packed_note_content, note_header, note_type_id| {\n///     let hashes = if note_type_id == MyNoteType::get_note_type_id() {\n///         assert(packed_note_content.len() == MY_NOTE_TYPE_SERIALIZATION_LENGTH);\n///         dep::aztec::note::utils::compute_note_hash_and_optionally_a_nullifier(\n///             MyNoteType::unpack_content,\n///             note_header,\n///             true,\n///             packed_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, packed_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 =\n                compute_note_hash_and_nullifier(packed_note_content, header, note_type_id).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                        packed_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 packed_note_content = array::subbvec(log_plaintext, NOTE_LOG_RESERVED_FIELDS);\n\n    (storage_slot, note_type_id, packed_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"
     },
-    "122": {
+    "121": {
       "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 packed_note_content = Note::pack_content(*note);\n    notify_created_note(\n        storage_slot,\n        Note::get_note_type_id(),\n        packed_note_content,\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"
     },
-    "124": {
+    "123": {
       "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"
     },
-    "126": {
+    "125": {
       "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    packed_note_content: [Field; N],\n    selector: PropertySelector,\n) -> Field {\n    // Selectors use PropertySelectors in order to locate note properties inside the packed note.\n    // This allows easier packing and custom (un)packing schemas. A note property is located\n    // inside the packed note using the index inside the array, a byte offset and a length.\n    let value: [u8; 32] = packed_note_content[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_content<let N: u32>(\n    packed_note_content: [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(packed_note_content, 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.pack_content();\n            check_note_header(*context, storage_slot, note);\n            check_note_content(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"
     },
-    "132": {
+    "131": {
       "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    unpack_content: fn([Field; N]) -> T,\n    note_header: NoteHeader,\n    compute_nullifier: bool,\n    packed_note_content: [Field; S],\n) -> [Field; 4]\nwhere\n    T: NoteInterface<N> + NullifiableNote,\n{\n    let mut note = unpack_content(array::subarray(packed_note_content, 0));\n    note.set_header(note_header);\n\n    let note_hash = note.compute_note_hash();\n    let siloed_note_hash = compute_siloed_note_hash(note_header.contract_address, note_hash);\n    let unique_note_hash = compute_unique_note_hash(note_header.nonce, siloed_note_hash);\n\n    let inner_nullifier = if compute_nullifier {\n        note.compute_nullifier_without_context()\n    } else {\n        0\n    };\n    // docs:start:compute_note_hash_and_optionally_a_nullifier_returns\n    [note_hash, unique_note_hash, siloed_note_hash, inner_nullifier]\n    // docs:end:compute_note_hash_and_optionally_a_nullifier_returns\n}\n"
     },
-    "134": {
+    "133": {
       "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"
     },
-    "135": {
+    "134": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/oracle/enqueue_public_function_call.nr",
       "source": "use dep::protocol_types::{abis::function_selector::FunctionSelector, address::AztecAddress};\n\n#[oracle(enqueuePublicFunctionCall)]\nunconstrained fn enqueue_public_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn enqueue_public_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    enqueue_public_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\n#[oracle(setPublicTeardownFunctionCall)]\nunconstrained fn set_public_teardown_function_call_oracle(\n    _contract_address: AztecAddress,\n    _function_selector: FunctionSelector,\n    _args_hash: Field,\n    _side_effect_counter: u32,\n    _is_static_call: bool,\n) -> Field {}\n\npub unconstrained fn set_public_teardown_function_call_internal(\n    contract_address: AztecAddress,\n    function_selector: FunctionSelector,\n    args_hash: Field,\n    side_effect_counter: u32,\n    is_static_call: bool,\n) -> Field {\n    set_public_teardown_function_call_oracle(\n        contract_address,\n        function_selector,\n        args_hash,\n        side_effect_counter,\n        is_static_call,\n    )\n}\n\npub fn notify_set_min_revertible_side_effect_counter(counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter) };\n}\n\npub unconstrained fn notify_set_min_revertible_side_effect_counter_oracle_wrapper(counter: u32) {\n    notify_set_min_revertible_side_effect_counter_oracle(counter);\n}\n\n#[oracle(notifySetMinRevertibleSideEffectCounter)]\nunconstrained fn notify_set_min_revertible_side_effect_counter_oracle(_counter: u32) {}\n"
     },
-    "136": {
+    "135": {
       "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"
     },
-    "137": {
+    "136": {
       "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\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"
     },
-    "138": {
+    "137": {
       "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    /// 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"
     },
-    "143": {
+    "142": {
       "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"
     },
-    "144": {
+    "143": {
       "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"
     },
-    "147": {
+    "146": {
       "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"
     },
-    "148": {
+    "147": {
       "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    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        notify_created_note_oracle_wrapper(\n            storage_slot,\n            note_type_id,\n            packed_note_content,\n            note_hash,\n            counter,\n        )\n    };\n}\n\n/// Notifies the simulator that a note has been nullified, so that it is no longer returned in future read requests in\n/// the same transaction. This note should only be removed to the non-volatile database if its nullifier is found in an\n/// actual block.\npub fn notify_nullified_note(nullifier: Field, note_hash: Field, counter: u32) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { notify_nullified_note_oracle_wrapper(nullifier, note_hash, counter) };\n}\n\n/// Notifies the simulator that a non-note nullifier has been created, so that it can be used for note nonces.\npub fn notify_created_nullifier(nullifier: Field) {\n    // This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to call.\n    unsafe { notify_created_nullifier_oracle_wrapper(nullifier) };\n}\n\nunconstrained fn notify_created_note_oracle_wrapper<let N: u32>(\n    storage_slot: Field,\n    note_type_id: Field,\n    packed_note_content: [Field; N],\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_created_note_oracle(\n        storage_slot,\n        note_type_id,\n        packed_note_content,\n        note_hash,\n        counter,\n    );\n}\n\n#[oracle(notifyCreatedNote)]\nunconstrained fn notify_created_note_oracle<let N: u32>(\n    _storage_slot: Field,\n    _note_type_id: Field,\n    _packed_note_content: [Field; N],\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_nullified_note_oracle_wrapper(\n    nullifier: Field,\n    note_hash: Field,\n    counter: u32,\n) {\n    let _ = notify_nullified_note_oracle(nullifier, note_hash, counter);\n}\n\n#[oracle(notifyNullifiedNote)]\nunconstrained fn notify_nullified_note_oracle(\n    _nullifier: Field,\n    _note_hash: Field,\n    _counter: u32,\n) -> Field {}\n\nunconstrained fn notify_created_nullifier_oracle_wrapper(nullifier: Field) {\n    let _ = notify_created_nullifier_oracle(nullifier);\n}\n\n#[oracle(notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_nullifier: Field) -> Field {}\n\n#[oracle(getNotes)]\nunconstrained fn get_notes_oracle<let N: u32, let S: u32>(\n    _storage_slot: Field,\n    _num_selects: u8,\n    _select_by_indexes: [u8; N],\n    _select_by_offsets: [u8; N],\n    _select_by_lengths: [u8; N],\n    _select_values: [Field; N],\n    _select_comparators: [u8; N],\n    _sort_by_indexes: [u8; N],\n    _sort_by_offsets: [u8; N],\n    _sort_by_lengths: [u8; N],\n    _sort_order: [u8; N],\n    _limit: u32,\n    _offset: u32,\n    _status: u8,\n    _return_size: u32,\n    _placeholder_fields: [Field; S],\n) -> [Field; S] {}\n\nunconstrained fn get_notes_oracle_wrapper<let N: u32, let S: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; N],\n    select_by_offsets: [u8; N],\n    select_by_lengths: [u8; N],\n    select_values: [Field; N],\n    select_comparators: [u8; N],\n    sort_by_indexes: [u8; N],\n    sort_by_offsets: [u8; N],\n    sort_by_lengths: [u8; N],\n    sort_order: [u8; N],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_fields: [Field; S],\n) -> [Field; S] {\n    let return_size = placeholder_fields.len() as u32;\n    get_notes_oracle(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        return_size,\n        placeholder_fields,\n    )\n}\n\npub unconstrained fn get_notes<Note, let N: u32, let M: u32, let S: u32, let NS: u32>(\n    storage_slot: Field,\n    num_selects: u8,\n    select_by_indexes: [u8; M],\n    select_by_offsets: [u8; M],\n    select_by_lengths: [u8; M],\n    select_values: [Field; M],\n    select_comparators: [u8; M],\n    sort_by_indexes: [u8; M],\n    sort_by_offsets: [u8; M],\n    sort_by_lengths: [u8; M],\n    sort_order: [u8; M],\n    limit: u32,\n    offset: u32,\n    status: u8,\n    mut placeholder_opt_notes: [Option<Note>; S], // TODO: Remove it and use `limit` to initialize the note array.\n    placeholder_fields: [Field; NS], // TODO: Remove it and use `limit` to initialize the note array.\n    _placeholder_note_length: [Field; N], // Turbofish hack? Compiler breaks calculating read_offset unless we add this parameter\n) -> [Option<Note>; S]\nwhere\n    Note: NoteInterface<N>,\n{\n    sync_notes_oracle_wrapper();\n    let fields = get_notes_oracle_wrapper(\n        storage_slot,\n        num_selects,\n        select_by_indexes,\n        select_by_offsets,\n        select_by_lengths,\n        select_values,\n        select_comparators,\n        sort_by_indexes,\n        sort_by_offsets,\n        sort_by_lengths,\n        sort_order,\n        limit,\n        offset,\n        status,\n        placeholder_fields,\n    );\n    let num_notes = fields[0] as u32;\n    let contract_address = AztecAddress::from_field(fields[1]);\n    for i in 0..placeholder_opt_notes.len() {\n        if i < num_notes {\n            // lengths named as per typescript.\n            let return_header_length: u32 = 2; // num_notes & contract_address.\n            let extra_preimage_length: u32 = 2; // nonce & note_hash_counter.\n            let read_offset: u32 = return_header_length + i * (N + extra_preimage_length);\n\n            let nonce = fields[read_offset];\n            let note_hash_counter = fields[read_offset + 1] as u32;\n            let note_content = array::subarray(fields, read_offset + 2);\n\n            let mut note = Note::unpack_content(note_content);\n            note.set_header(NoteHeader { contract_address, nonce, storage_slot, note_hash_counter });\n\n            placeholder_opt_notes[i] = Option::some(note);\n        };\n    }\n    placeholder_opt_notes\n}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before the\n/// current transaction is included in a block. While this might seem of little use at first, certain design patterns\n/// benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier) == 1\n}\n\n#[oracle(checkNullifierExists)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> Field {}\n\n/// Same as `get_indexed_tagging_secret_as_sender`, except it returns the derived tag, ready to be included in a log.\npub unconstrained fn get_app_tag_as_sender(sender: AztecAddress, recipient: AztecAddress) -> Field {\n    get_indexed_tagging_secret_as_sender(sender, recipient).compute_tag(recipient)\n}\n\n/// Returns the tagging secret for a given sender and recipient pair, siloed for the current contract address.\n/// Includes the last known index used to send a note tagged with this secret.\n/// For this to work, PXE must know the ivsk_m of the sender.\n/// For the recipient's side, only the address is needed.\npub unconstrained fn get_indexed_tagging_secret_as_sender(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) -> IndexedTaggingSecret {\n    let result = get_indexed_tagging_secret_as_sender_oracle(sender, recipient);\n    IndexedTaggingSecret::deserialize(result)\n}\n\n#[oracle(getIndexedTaggingSecretAsSender)]\nunconstrained fn get_indexed_tagging_secret_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) -> [Field; INDEXED_TAGGING_SECRET_LENGTH] {}\n\n/// Notifies the simulator that a tag has been used in a note, and to therefore increment the associated index so that\n/// future notes get a different tag and can be discovered by the recipient.\n/// This change should only be persisted in a non-volatile database if the tagged log is found in an actual block -\n/// otherwise e.g. a reverting transaction can cause the sender to accidentally skip indices and later produce notes\n/// that are not found by the recipient.\npub fn increment_app_tagging_secret_index_as_sender(sender: AztecAddress, recipient: AztecAddress) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        increment_app_tagging_secret_index_as_sender_wrapper(sender, recipient);\n    }\n}\n\nunconstrained fn increment_app_tagging_secret_index_as_sender_wrapper(\n    sender: AztecAddress,\n    recipient: AztecAddress,\n) {\n    increment_app_tagging_secret_index_as_sender_oracle(sender, recipient);\n}\n\n#[oracle(incrementAppTaggingSecretIndexAsSender)]\nunconstrained fn increment_app_tagging_secret_index_as_sender_oracle(\n    _sender: AztecAddress,\n    _recipient: AztecAddress,\n) {}\n\n/// Finds new notes that may have been sent to all registered accounts in PXE in the current contract and makes them available\n/// for later querying via the `get_notes` oracle.\npub fn sync_notes() {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe {\n        sync_notes_oracle_wrapper();\n    }\n}\n\nunconstrained fn sync_notes_oracle_wrapper() {\n    sync_notes_oracle();\n}\n\n#[oracle(syncNotes)]\nunconstrained fn sync_notes_oracle() {}\n"
     },
-    "150": {
+    "149": {
       "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"
     },
-    "156": {
+    "155": {
       "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, 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<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"
     },
@@ -5943,19 +5941,19 @@
       "path": "std/field/bn254.nr",
       "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\nglobal PLO: Field = 53438638232309528389504892708671455233;\nglobal PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\nglobal TWO_POW_64: Field = 0x10000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(mut x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 64 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low_lower_64 = (x as u64) as Field;\n    x = (x - low_lower_64) / TWO_POW_64;\n    let low_upper_64 = (x as u64) as Field;\n\n    let high = (x - low_upper_64) / TWO_POW_64;\n    let low = low_upper_64 * TWO_POW_64 + low_lower_64;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    /// Safety: borrow is enforced to be boolean due to its type.\n    /// if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    /// if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        /// Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            /// Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        /// Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        /// Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_decompose_unconstrained() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_assert_gt() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    unconstrained fn check_assert_gt_unconstrained() {\n        assert_gt(1, 0);\n        assert_gt(0x100, 0);\n        assert_gt((0 - 1), (0 - 2));\n        assert_gt(TWO_POW_128, 0);\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    unconstrained fn check_gt_unconstrained() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n}\n"
     },
-    "183": {
+    "182": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/array/subarray.nr",
       "source": "/// Returns `DST_LEN` elements from a source array, starting at `offset`. `DST_LEN` must not be larger than the number\n/// of elements past `offset`.\n///\n/// Examples:\n/// ```\n/// let foo: [Field; 2] = subarray([1, 2, 3, 4, 5], 2);\n/// assert_eq(foo, [3, 4]);\n///\n/// let bar: [Field; 5] = subarray([1, 2, 3, 4, 5], 2); // fails - we can't return 5 elements since only 3 remain\n/// ```\npub fn subarray<T, let SRC_LEN: u32, let DST_LEN: u32>(\n    src: [T; SRC_LEN],\n    offset: u32,\n) -> [T; DST_LEN] {\n    assert(offset + DST_LEN <= SRC_LEN, \"DST_LEN too large for offset\");\n\n    let mut dst: [T; DST_LEN] = std::mem::zeroed();\n    for i in 0..DST_LEN {\n        dst[i] = src[i + offset];\n    }\n\n    dst\n}\n\nmod test {\n    use super::subarray;\n\n    #[test]\n    unconstrained fn subarray_into_empty() {\n        // In all of these cases we're setting DST_LEN to be 0, so we always get back an emtpy array.\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 2), []);\n    }\n\n    #[test]\n    unconstrained fn subarray_complete() {\n        assert_eq(subarray::<Field, _, _>([], 0), []);\n        assert_eq(subarray([1, 2, 3, 4, 5], 0), [1, 2, 3, 4, 5]);\n    }\n\n    #[test]\n    unconstrained fn subarray_different_end_sizes() {\n        // We implicitly select how many values to read in the size of the return array\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4, 5]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3, 4]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2, 3]);\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [2]);\n    }\n\n    #[test(should_fail_with = \"DST_LEN too large for offset\")]\n    unconstrained fn subarray_offset_too_large() {\n        // With an offset of 1 we can only request up to 4 elements\n        let _: [_; 5] = subarray([1, 2, 3, 4, 5], 1);\n    }\n\n    #[test(should_fail)]\n    unconstrained fn subarray_bad_return_value() {\n        assert_eq(subarray([1, 2, 3, 4, 5], 1), [3, 3, 4, 5]);\n    }\n}\n"
     },
-    "184": {
+    "183": {
       "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"
     },
-    "185": {
+    "184": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/bytes.nr",
       "source": "use crate::oracle::random::random;\n\n/// Converts the input bytes into an array of fields. A Field is ~254 bits meaning that each field can store 31 whole bytes.\n///\n/// The input bytes are chunked into chunks of 31 bytes. Each 31-byte chunk is viewed as big-endian, and is converted into a Field. If the last chunk\n/// is less than 31 bytes long, then only the relevant bytes are considered.\n/// For example, [1, 10, 3] is encoded as [1 * 256^2 + 10 * 256 + 3]\n/// Note: ceil(N / 31) = (N + 30) / 31\npub fn be_bytes_31_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; (N + 30) / 31] {\n    let mut fields = [0; (N + 30) / 31];\n\n    // There are N / 31 whole fields that can be populated.\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + j] as Field;\n        }\n        fields[i] = field;\n    }\n\n    // Note: if 31 divides N, then this loop does not execute.\n    // ceil(N/31) - floor(N/31) = 1, unless 31 divides N, in which case it's 0.\n    for _ in 0..((N + 30) / 31) - (N / 31) {\n        let mut final_field = 0;\n        let final_field_idx = fields.len() - 1;\n        let final_offset = final_field_idx * 31;\n        // N - ((N / 31) * 31) = N - floor(N/31) * 31 = the number of bytes to go in the final field.\n        for j in 0..N - ((N / 31) * 31) {\n            // Shift the existing value left by 8 bits and add the new byte\n            final_field = final_field * 256 + bytes[final_offset + j] as Field;\n        }\n\n        fields[final_field_idx] = final_field;\n    }\n\n    fields\n}\n\npub fn le_bytes_31_to_fields<let N: u32>(bytes: [u8; N]) -> [Field; (N + 30) / 31] {\n    let mut fields = [0; (N + 30) / 31];\n\n    // There are N / 31 whole fields that can be populated.\n    for i in 0..N / 31 {\n        let mut field = 0;\n        for j in 0..31 {\n            let k = 31 - j - 1; // iterate in reverse.\n            // Shift the existing value left by 8 bits and add the new byte\n            field = field * 256 + bytes[i * 31 + k] as Field;\n        }\n        fields[i] = field;\n    }\n\n    // Note: if 31 divides N, then this loop does not execute.\n    // ceil(N/31) - floor(N/31) = 1, unless 31 divides N, in which case it's 0.\n    for _ in 0..((N + 30) / 31) - (N / 31) {\n        let mut final_field = 0;\n        let final_field_idx = fields.len() - 1;\n        let final_offset = final_field_idx * 31;\n        // N - ((N / 31) * 31) = N - floor(N/31) * 31 = the number of bytes to go in the final field.\n        for j in 0..N - ((N / 31) * 31) {\n            let k = (N - ((N / 31) * 31)) - j - 1; // iterate in reverse.\n            // Shift the existing value left by 8 bits and add the new byte\n            final_field = final_field * 256 + bytes[final_offset + k] as Field;\n        }\n        fields[final_field_idx] = final_field;\n    }\n\n    fields\n}\n\n/// Converts an input array of fields into a single array of bytes.\n/// Each input field must contain only 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 big-endian bytes, and the resulting 31-byte\n/// chunks are concatenated back together in the order of the original fields.\n///\n/// It appears that the original author of this function wants to give the caller some control\n/// over the number of bytes that are returned: the final field can be mapped to fewer than 31 bytes,\n/// based on the caller's choice of M.\n/// Given the input is N fields, and each field (except the last) is mapped to 31 bytes,\n/// we definitely need M > (N - 1) * 31 to cover those first (N - 1) fields. Hence the static assertion.\n/// TODO: this is the same as the \"le\" version of this function, save for the `field.to_be_bytes()` calls. I tried passing the conversion function in as a parameter, to reduce code duplication, but couldn't get it to work.\npub fn fields_to_be_bytes_31<let N: u32, let M: u32>(fields: [Field; N]) -> [u8; M] {\n    let mut bytes = [0; M];\n\n    std::static_assert(M > (N - 1) * 31, \"Not enough output bytes specified\");\n    // We make this assertion to keep the logic simpler:\n    std::static_assert(N * 31 >= M, \"Too many output bytes specified.\");\n\n    for i in 0..N - 1 {\n        let field = fields[i];\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_be_bytes();\n\n        for j in 0..31 {\n            bytes[i * 31 + j] = field_as_bytes[j];\n        }\n    }\n\n    let final_field = fields[N - 1];\n    final_field.assert_max_bit_size::<8 * (M - ((N - 1) * 31))>();\n\n    let final_field_as_bytes: [u8; M - ((N - 1) * 31)] = final_field.to_be_bytes();\n\n    let start_index = (N - 1) * 31;\n    for j in 0..M - ((N - 1) * 31) {\n        bytes[start_index + j] = final_field_as_bytes[j];\n    }\n\n    bytes\n}\n\n/// Converts an input array of fields into a single array of bytes.\n/// Each input field must contain only 31 bytes (this is constrained to be so).\n/// Each field is converted into 31 little-endian bytes, and the resulting 31-byte\n/// chunks are concatenated back together in the order of the original fields. You'll\n/// end up with quite a strange ordering of bytes if you use this particular function.\npub fn fields_to_le_bytes_31<let N: u32, let M: u32>(fields: [Field; N]) -> [u8; M] {\n    let mut bytes = [0; M];\n\n    std::static_assert(M > (N - 1) * 31, \"Not enough output bytes specified\");\n    // We make this assertion to keep the logic simpler:\n    std::static_assert(N * 31 >= M, \"Too many output bytes specified.\");\n\n    for i in 0..N - 1 {\n        let field = fields[i];\n\n        // We expect that the field contains at most 31 bytes of information.\n        field.assert_max_bit_size::<248>();\n\n        // Now we can safely convert the field to 31 bytes.\n        let field_as_bytes: [u8; 31] = field.to_le_bytes();\n\n        for j in 0..31 {\n            bytes[i * 31 + j] = field_as_bytes[j];\n        }\n    }\n\n    let final_field = fields[N - 1];\n    final_field.assert_max_bit_size::<8 * (M - ((N - 1) * 31))>();\n\n    let final_field_as_bytes: [u8; M - ((N - 1) * 31)] = final_field.to_le_bytes();\n\n    let start_index = (N - 1) * 31;\n    for j in 0..M - ((N - 1) * 31) {\n        bytes[start_index + j] = final_field_as_bytes[j];\n    }\n\n    bytes\n}\n\n/// Converts an input array of fields into a single array of bytes.\n/// Each field is converted to a 32-byte big-endian array.\n/// Since a field is ~254 bits, you'll end up with a subtle 2-bit \"gap\" at the big end,\n/// every 32 bytes. Be careful that such a gap doesn't leak information!\npub fn fields_to_be_bytes_32<let N: u32>(fields: [Field; N]) -> [u8; 32 * N] {\n    let mut bytes = [0; 32 * N];\n\n    for i in 0..N {\n        let field = fields[i];\n        let field_as_bytes: [u8; 32] = field.to_be_bytes();\n\n        for j in 0..32 {\n            bytes[i * 32 + j] = field_as_bytes[j];\n        }\n    }\n\n    bytes\n}\n\nunconstrained fn byte_to_bits(byte: u8) -> [u1; 8] {\n    let mut mut_byte = byte;\n    let mut bits: [u1; 8] = [0; 8];\n    for i in 0..8 {\n        bits[i] = (mut_byte & 1) as u1;\n        mut_byte >>= 1;\n    }\n    bits\n}\n\n/// Returns as many random bytes as specified through N.\npub unconstrained 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/// Returns as many random bits as specified through N.\nunconstrained fn get_random_bits<let N: u32>() -> [u1; N] {\n    // Note: (N + 7) / 8 = ceil(N / 8)\n    let bytes = get_random_bytes::<(N + 7) / 8>();\n    let mut bits: [u1; N] = [0; N];\n    for i in 0..bytes.len() - 1 {\n        let mut byte = bytes[i];\n        for j in 0..8 {\n            let bit_idx = i * 8 + j;\n            bits[bit_idx] = (byte & 1) as u1;\n            byte >>= 1;\n        }\n    }\n\n    // N - ((N / 8) * 8) = N - floor(N/8) * 8 = the number of bits remaining.\n    let byte_idx = bytes.len() - 1;\n    let mut byte = bytes[byte_idx];\n    for j in 0..N - ((N / 8) * 8) {\n        let bit_idx = (byte_idx) * 8 + j;\n        bits[bit_idx] = (byte & 1) as u1;\n        byte >>= 1;\n    }\n\n    bits\n}\n\n/// Returns random bits, in chunks, according to the provided numeric generics.\nunconstrained fn get_chunks_of_random_bits<let NUM_CHUNKS: u32, let NUM_BITS: u32>() -> [[u1; NUM_BITS]; NUM_CHUNKS] {\n    let random_bits = get_random_bits::<NUM_CHUNKS * NUM_BITS>();\n    let mut chunks: [[u1; NUM_BITS]; NUM_CHUNKS] = [[0; NUM_BITS]; NUM_CHUNKS];\n    for i in 0..NUM_CHUNKS {\n        let mut chunk: [u1; NUM_BITS] = [0; NUM_BITS];\n        for j in 0..NUM_BITS {\n            chunk[j] = random_bits[i * NUM_BITS + j];\n        }\n        chunks[i] = chunk;\n    }\n    chunks\n}\n\n/**\n * Helper fn for be/le_bytes_to_padded_fields() fns.\n */\nfn pad_31_byte_fields_with_random_bits<let N: u32>(input: [Field; N]) -> [Field; N] {\n    /// Safety: we can't constrain whether or not the returned bits are actually random;\n    /// we can only rely on it being in the caller's best interest.\n    let chunks_of_random_bits = unsafe { get_chunks_of_random_bits::<((N + 30) / 31), 6>() };\n    let mut fields = input;\n    // We push the random bits to the \"big end\" of each field\n    let TWO_POW_248 = 0x100000000000000000000000000000000000000000000000000000000000000;\n    for i in 0..fields.len() {\n        let mut shift = TWO_POW_248;\n        for j in 0..5 {\n            fields[i] += shift * chunks_of_random_bits[i][j] as Field;\n            shift *= 2;\n        }\n\n        // This might overflow the field modulus, so we need to be careful.\n        // By this point, shift = 2 ^ 253, so will populate the 254th bit (counting from 1)\n        let field_with_254th_bit = fields[i] + shift * chunks_of_random_bits[i][6 - 1] as Field;\n\n        // Expensive comparison (one for each field), but it's important -- if we want to hide that we were\n        // working with bytes -- that we include the 254th random bit when it fits.\n        fields[i] = if (fields[i].lt(field_with_254th_bit)) {\n            field_with_254th_bit\n        } else {\n            fields[i]\n        };\n    }\n    fields\n}\n\n/**\n * The above functions be_bytes_31_to_fields and le_bytes_31_to_fields have a privacy-leakage problem:\n * they result in fields which are all 248-bits instead of 254-bits.\n * That means if the above functions are used to convert a ciphertext from bytes to\n * fields, it leaks (with very high probability) to all observers of the log that the\n * ciphertext was created with a \"bit twiddly\" encryption scheme like AES.\n * This reduces privacy sets for all apps.\n *\n * This function seeks to \"pad\" those remaining 6 bits with randomness, so that all\n * encrypted logs look even more similar (full fields of 254-bits of random-looking\n * information). Of course, this adds some extra constraints, unfortunately.\n */\npub fn le_bytes_to_padded_fields<let N: u32>(input: [u8; N]) -> [Field; (N + 30) / 31] {\n    let mut fields = le_bytes_31_to_fields(input);\n    pad_31_byte_fields_with_random_bits(fields)\n}\n\npub fn be_bytes_to_padded_fields<let N: u32>(input: [u8; N]) -> [Field; (N + 30) / 31] {\n    let mut fields = be_bytes_31_to_fields(input);\n    pad_31_byte_fields_with_random_bits(fields)\n}\n\nmod test {\n    use crate::utils::bytes::{\n        be_bytes_31_to_fields, fields_to_be_bytes_31, fields_to_le_bytes_31, le_bytes_31_to_fields,\n    };\n\n    // BE BYTES\n\n    #[test]\n    fn test_be_bytes_31_to_1_field() {\n        let input = [\n            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,\n        ];\n        let output = be_bytes_31_to_fields(input);\n\n        assert_eq(output[0], 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f);\n    }\n\n    #[test]\n    fn test_1_field_to_be_bytes_31() {\n        let input = [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f];\n        let output: [u8; 31] = fields_to_be_bytes_31(input);\n\n        assert_eq(\n            output,\n            [\n                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n                24, 25, 26, 27, 28, 29, 30, 31,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_3_small_fields_to_be_bytes_31() {\n        let input = [1, 2, 3];\n        let output: [u8; 93] = fields_to_be_bytes_31(input);\n\n        // Each field should occupy 31 bytes with the non-zero value being placed in the last one.\n        assert_eq(\n            output,\n            [\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,\n                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, 0, 0,\n                0, 0, 0, 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,\n                0, 0, 0, 0, 0, 0, 0, 0, 3,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_3_small_fields_to_fewer_be_bytes() {\n        let input = [1, 2, 3];\n        let output: [u8; 63] = fields_to_be_bytes_31(input);\n        println(f\"output: {output}\");\n\n        // First 2 fields should occupy 31 bytes with the non-zero value being placed in the last one while the last\n        // field should occupy 1 byte. There is not information destruction here because the last field fits into\n        // 1 byte.\n        assert_eq(\n            output,\n            [\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,\n                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, 0, 0,\n                0, 0, 0, 0, 0, 2, 3,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_be_bytes_31_to_2_fields() {\n        let input = [\n            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,\n            47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,\n        ];\n        let output = be_bytes_31_to_fields(input);\n\n        assert_eq(output[0], 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f);\n        assert_eq(output[1], 0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b);\n    }\n\n    #[test]\n    fn test_2_fields_to_be_bytes_31() {\n        let input = [\n            0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f,\n            0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b,\n        ];\n        let output: [u8; 62] = fields_to_be_bytes_31(input);\n\n        assert_eq(\n            output,\n            [\n                1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n                24, 25, 26, 27, 28, 29, 30, 31, 0, 0, 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,\n                43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_large_random_be_bytes_31_input_to_fields_and_back(input: [u8; 128]) {\n        let output = be_bytes_31_to_fields(input);\n        let input_back: [u8; 128] = fields_to_be_bytes_31(output);\n\n        assert_eq(input, input_back);\n    }\n\n    // I need to get an array of random values lower than 2^248 on input and since there is no u248 type and modulo\n    // operation is not supported on a Field (to do field % 2^248), I will take multiple smaller values and combine\n    // them to get a value lower than 2^248.\n    #[test]\n    fn test_large_random_input_to_be_bytes_31_and_back(\n        input1: [u64; 5],\n        input2: [u64; 5],\n        input3: [u64; 5],\n        input4: [u32; 5],\n        input5: [u16; 5],\n        input6: [u8; 5],\n    ) {\n        let mut input = [0; 5];\n        for i in 0..5 {\n            input[i] = (input1[i] as Field * 2.pow_32(184))\n                + (input2[i] as Field * 2.pow_32(120))\n                + (input3[i] as Field * 2.pow_32(56))\n                + (input4[i] as Field * 2.pow_32(24))\n                + (input5[i] as Field * 2.pow_32(8))\n                + input6[i] as Field;\n        }\n\n        let output: [u8; 155] = fields_to_be_bytes_31(input);\n        let input_back = be_bytes_31_to_fields(output);\n\n        assert_eq(input, input_back);\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn test_too_few_destination_be_bytes() {\n        // We should get an error here because first field gets converted to 31 bytes and the second field needs\n        // at least 2 bytes but we provide it with 1.\n        let input = [1, 256];\n        let _ignored_result: [u8; 32] = fields_to_be_bytes_31(input);\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn test_fields_to_be_bytes_31_value_too_large() {\n        let input = [2.pow_32(248)]; // this number is 1 bit larger than 31 bytes.\n        let _ignored_result: [u8; 31] = fields_to_be_bytes_31(input);\n    }\n\n    #[test]\n    fn test_fields_to_be_bytes_31_max_value() {\n        let input = [2.pow_32(248) - 1];\n        let result: [u8; 31] = fields_to_be_bytes_31(input);\n\n        // We check that all the bytes were set to max value (255)\n        for i in 0..31 {\n            assert_eq(result[i], 255);\n        }\n    }\n\n    // LE BYTES\n\n    #[test]\n    fn test_le_bytes_31_to_1_field() {\n        let input = [\n            31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10,\n            9, 8, 7, 6, 5, 4, 3, 2, 1,\n        ];\n        let output = le_bytes_31_to_fields(input);\n\n        assert_eq(output[0], 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f);\n    }\n\n    #[test]\n    fn test_1_field_to_le_bytes_31() {\n        let input = [0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f];\n        let output: [u8; 31] = fields_to_le_bytes_31(input);\n\n        assert_eq(\n            output,\n            [\n                31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11,\n                10, 9, 8, 7, 6, 5, 4, 3, 2, 1,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_3_small_fields_to_le_bytes_31() {\n        let input = [1, 2, 3];\n        let output: [u8; 93] = fields_to_le_bytes_31(input);\n\n        // Each field should occupy 31 bytes with the non-zero value being placed in the last one.\n        assert_eq(\n            output,\n            [\n                1, 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, 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,\n                0, 0, 0, 0, 0, 0, 3, 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,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_3_small_fields_to_fewer_le_bytes() {\n        let input = [1, 2, 3];\n        let output: [u8; 63] = fields_to_le_bytes_31(input);\n\n        // First 2 fields should occupy 31 bytes with the non-zero value being placed in the last one while the last\n        // field should occupy 1 byte. There is not information destruction here because the last field fits into\n        // 1 byte.\n        assert_eq(\n            output,\n            [\n                1, 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, 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,\n                0, 0, 0, 0, 0, 0, 3,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_le_bytes_31_to_2_fields() {\n        let input = [\n            59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38,\n            37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,\n            15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,\n        ];\n        let output = le_bytes_31_to_fields(input);\n\n        assert_eq(output[0], 0x1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b);\n        assert_eq(output[1], 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c);\n    }\n\n    #[test]\n    fn test_2_fields_to_le_bytes_31() {\n        let input = [\n            0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f,\n            0x202122232425262728292a2b2c2d2e2f303132333435363738393a3b,\n        ];\n        let output: [u8; 62] = fields_to_le_bytes_31(input);\n\n        assert_eq(\n            output,\n            [\n                31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11,\n                10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47,\n                46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 32, 0, 0, 0,\n            ],\n        );\n    }\n\n    #[test]\n    fn test_large_random_le_bytes_input_to_fields_and_back(input: [u8; 128]) {\n        let output = le_bytes_31_to_fields(input);\n        let input_back: [u8; 128] = fields_to_le_bytes_31(output);\n\n        assert_eq(input, input_back);\n    }\n\n    // I need to get an array of random values lower than 2^248 on input and since there is no u248 type and modulo\n    // operation is not supported on a Field (to do field % 2^248), I will take multiple smaller values and combine\n    // them to get a value lower than 2^248.\n    #[test]\n    fn test_large_random_input_to_le_bytes_and_back(\n        input1: [u64; 5],\n        input2: [u64; 5],\n        input3: [u64; 5],\n        input4: [u32; 5],\n        input5: [u16; 5],\n        input6: [u8; 5],\n    ) {\n        let mut input = [0; 5];\n        for i in 0..5 {\n            input[i] = (input1[i] as Field * 2.pow_32(184))\n                + (input2[i] as Field * 2.pow_32(120))\n                + (input3[i] as Field * 2.pow_32(56))\n                + (input4[i] as Field * 2.pow_32(24))\n                + (input5[i] as Field * 2.pow_32(8))\n                + input6[i] as Field;\n        }\n\n        let output: [u8; 155] = fields_to_le_bytes_31(input);\n        let input_back = le_bytes_31_to_fields(output);\n\n        assert_eq(input, input_back);\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn test_too_few_destination_le_bytes() {\n        // We should get an error here because first field gets converted to 31 bytes and the second field needs\n        // at least 2 bytes but we provide it with 1.\n        let input = [1, 256];\n        let _ignored_result: [u8; 32] = fields_to_le_bytes_31(input);\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn test_fields_to_le_bytes_31_value_too_large() {\n        let input = [2.pow_32(248)];\n        let _ignored_result: [u8; 31] = fields_to_le_bytes_31(input);\n    }\n\n    #[test]\n    fn test_fields_to_le_bytes_31_max_value() {\n        let input = [2.pow_32(248) - 1];\n        let result: [u8; 31] = fields_to_le_bytes_31(input);\n\n        // We check that all the bytes were set to max value (255)\n        for i in 0..31 {\n            assert_eq(result[i], 255);\n        }\n    }\n}\n"
     },
-    "189": {
+    "188": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/utils/point.nr",
       "source": "use crate::utils::field::sqrt;\nuse 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 point 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(p: 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(!p.is_infinite, \"Cannot serialize point at infinity as bytes.\");\n\n    let mut result: [u8; 32] = p.x.to_be_bytes();\n\n    if get_sign_of_point(p) {\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\n/**\n * Returns: true if p.y <= MOD_DIV_2, else false.\n */\npub fn get_sign_of_point(p: Point) -> bool {\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    !BN254_FR_MODULUS_DIV_2.lt(p.y)\n}\n\npub fn point_from_x_coord(x: Field) -> Point {\n    // y ^ 2 = x ^ 3 - 17\n    let rhs = x * x * x - 17;\n    let y = sqrt(rhs).unwrap();\n    Point { x, y, is_infinite: false }\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"
     },
@@ -5967,19 +5965,19 @@
       "path": "std/hash/mod.nr",
       "source": "pub mod poseidon;\npub mod poseidon2;\npub mod keccak;\npub mod sha256;\npub mod sha512;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::uint128::U128;\n\n// Kept for backwards compatibility\npub use sha256::{digest, sha256, sha256_compression, sha256_var};\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n#[foreign(blake3)]\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        // we use the unsafe version because the multi_scalar_mul will constrain the scalars.\n        points[i] = from_field_unsafe(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = from_field_unsafe(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars)[0]\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    // TODO(https://github.com/noir-lang/noir/issues/5672): Add back assert_constant on starting_index\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\n#[field(bn254)]\n// Same as from_field but:\n// does not assert the limbs are 128 bits\n// does not assert the decomposition does not overflow the EmbeddedCurveScalar\nfn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {\n    /// Safety: xlo and xhi decomposition is checked below\n    let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };\n    // Check that the decomposition is correct\n    assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);\n    EmbeddedCurveScalar { lo: xlo, hi: xhi }\n}\n\npub fn hash_to_field(inputs: [Field]) -> Field {\n    let mut sum = 0;\n\n    for input in inputs {\n        let input_bytes: [u8; 32] = input.to_le_bytes();\n        sum += crate::field::bytes32_to_field(blake2s(input_bytes));\n    }\n\n    sum\n}\n\n// docs:start:keccak256\npub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32]\n// docs:end:keccak256\n{\n    crate::hash::keccak::keccak256(input, message_size)\n}\n\n#[foreign(poseidon2_permutation)]\npub fn poseidon2_permutation<let N: u32>(_input: [Field; N], _state_length: u32) -> [Field; N] {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: StructDefinition) -> Quoted {\n    let name = quote { Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: std::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher<H>\nwhere\n    H: Hasher,\n{\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher<H> for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u1 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl Hash for U128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self.lo as Field);\n        H::write(state, self.hi as Field);\n    }\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n            is_infinite: false,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n            is_infinite: false,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n            is_infinite: false,\n        },\n    );\n}\n"
     },
-    "244": {
+    "243": {
       "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"
     },
-    "251": {
+    "250": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
       "source": "use crate::{\n    abis::function_selector::FunctionSelector,\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{\n        AZTEC_ADDRESS_LENGTH, FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__CONTRACT_ADDRESS_V1,\n        MAX_FIELD_VALUE,\n    },\n    contract_class_id::ContractClassId,\n    hash::{poseidon2_hash_with_separator, private_functions_root_from_siblings},\n    merkle_tree::membership::MembershipWitness,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, 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"
     },
-    "254": {
+    "253": {
       "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"
     },
-    "256": {
+    "255": {
       "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"
     },
@@ -5987,19 +5985,19 @@
       "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"
     },
-    "261": {
+    "260": {
       "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, 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"
     },
-    "267": {
+    "266": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/debug_log.nr",
       "source": "/// Utility function to console.log data in the acir simulator.\n/// Example:\n///   debug_log(\"blah blah this is a debug string\");\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\n/// Utility function to console.log data in the acir simulator. This variant receives a format string in which the\n/// `${k}` tokens will be replaced with the k-eth value in the `args` array.\n/// Examples:\n///   debug_log_format(\"get_2(slot:{0}) =>\\n\\t0:{1}\\n\\t1:{2}\", [storage_slot, note0_hash, note1_hash]);\n///   debug_log_format(\"whole array: {}\", [e1, e2, e3, e4]);\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    /// Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    /// to call.\n    unsafe { debug_log_oracle_wrapper(msg, args) };\n}\n\npub unconstrained fn debug_log_oracle_wrapper<let M: u32, let N: u32>(\n    msg: str<M>,\n    args: [Field; N],\n) {\n    debug_log_oracle(msg, args.as_slice());\n}\n\n// WARNING: sometimes when using debug logs the ACVM errors with: `thrown: \"solver opcode resolution error: cannot solve opcode: expression has too many unknowns x155\"`\n#[oracle(debugLog)]\nunconstrained fn debug_log_oracle<let M: u32>(_msg: str<M>, args: [Field]) {}\n"
     },
-    "268": {
+    "267": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "use crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector,\n        log_hash::{LogHash, ScopedLogHash},\n        note_hash::ScopedNoteHash,\n        nullifier::ScopedNullifier,\n        private_log::{PrivateLog, PrivateLogData},\n        side_effect::{OrderedValue, scoped::Scoped},\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        FUNCTION_TREE_HEIGHT, GENERATOR_INDEX__NOTE_HASH_NONCE, GENERATOR_INDEX__OUTER_NULLIFIER,\n        GENERATOR_INDEX__SILOED_NOTE_HASH, GENERATOR_INDEX__UNIQUE_NOTE_HASH,\n    },\n    merkle_tree::root::root_from_sibling_path,\n    messaging::l2_to_l1_message::{L2ToL1Message, ScopedL2ToL1Message},\n    poseidon2::Poseidon2Sponge,\n    traits::{FromField, Hash, is_empty, ToField},\n    utils::field::field_from_bytes_32_trunc,\n};\nuse super::{constants::TWO_POW_64, utils::{arrays::array_concat, field::field_from_bytes}};\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        GENERATOR_INDEX__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_unique_note_hash(nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, GENERATOR_INDEX__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_siloed_note_hash(app: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), note_hash],\n        GENERATOR_INDEX__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique note hashes from siloed note hashes\npub fn compute_unique_siloed_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    if siloed_note_hash == 0 {\n        0\n    } else {\n        let nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n        compute_unique_note_hash(nonce, siloed_note_hash)\n    }\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn silo_note_hash(note_hash: ScopedNoteHash) -> Field {\n    if note_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_note_hash(note_hash.contract_address, note_hash.value())\n    }\n}\n\npub fn compute_siloed_nullifier(app: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [app.to_field(), nullifier],\n        GENERATOR_INDEX__OUTER_NULLIFIER,\n    )\n}\n\npub fn silo_nullifier(nullifier: ScopedNullifier) -> Field {\n    if nullifier.contract_address.is_zero() {\n        nullifier.value() // Return value instead of 0 because the first nullifier's contract address is zero.\n    } else {\n        compute_siloed_nullifier(nullifier.contract_address, nullifier.value())\n    }\n}\n\npub fn compute_siloed_private_log_field(contract_address: AztecAddress, field: Field) -> Field {\n    poseidon2_hash([contract_address.to_field(), field])\n}\n\npub fn silo_private_log(private_log: Scoped<PrivateLogData>) -> PrivateLog {\n    if private_log.contract_address.is_zero() {\n        private_log.inner.log\n    } else {\n        let mut fields = private_log.inner.log.fields;\n        fields[0] = compute_siloed_private_log_field(private_log.contract_address, fields[0]);\n        PrivateLog { fields }\n    }\n}\n\nfn compute_siloed_contract_class_log_hash(address: AztecAddress, log_hash: Field) -> Field {\n    accumulate_sha256([address.to_field(), log_hash])\n}\n\npub fn silo_contract_class_log_hash(log_hash: ScopedLogHash) -> Field {\n    if log_hash.contract_address.is_zero() {\n        0\n    } else {\n        compute_siloed_contract_class_log_hash(log_hash.contract_address, log_hash.value())\n    }\n}\n\npub fn merkle_hash(left: Field, right: Field) -> Field {\n    poseidon2_hash([left, right])\n}\n\npub fn compute_l2_to_l1_hash(\n    contract_address: AztecAddress,\n    recipient: EthAddress,\n    content: Field,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let mut bytes: [u8; 160] = std::mem::zeroed();\n\n    let inputs =\n        [contract_address.to_field(), rollup_version_id, recipient.to_field(), chain_id, content];\n    for i in 0..5 {\n        // TODO are bytes be in fr.to_buffer() ?\n        let item_bytes: [u8; 32] = inputs[i].to_be_bytes();\n        for j in 0..32 {\n            bytes[32 * i + j] = item_bytes[j];\n        }\n    }\n\n    sha256_to_field(bytes)\n}\n\npub fn silo_l2_to_l1_message(\n    msg: ScopedL2ToL1Message,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    if msg.contract_address.is_zero() {\n        0\n    } else {\n        compute_l2_to_l1_hash(\n            msg.contract_address,\n            msg.message.recipient,\n            msg.message.content,\n            rollup_version_id,\n            chain_id,\n        )\n    }\n}\n\n// Computes sha256 hash of 2 input hashes.\n//\n// NB: This method now takes in two 31 byte fields - it assumes that any input\n// is the result of a sha_to_field hash and => is truncated\n//\n// TODO(Jan and David): This is used for the encrypted_log hashes.\n// Can we check to see if we can just use hash_to_field or pedersen_compress here?\n//\npub fn accumulate_sha256(input: [Field; 2]) -> Field {\n    // This is a note about the cpp code, since it takes an array of Fields\n    // instead of a U128.\n    // 4 Field elements when converted to bytes will usually\n    // occupy 4 * 32 = 128 bytes.\n    // However, this function is making the assumption that each Field\n    // only occupies 128 bits.\n    //\n    // TODO(David): This does not seem to be getting guaranteed anywhere in the code?\n    // Concatentate two fields into 32x2 = 64 bytes\n    // accumulate_sha256 assumes that the inputs are pre-truncated 31 byte numbers\n    let mut hash_input_flattened = [0; 64];\n    for offset in 0..input.len() {\n        let input_as_bytes: [u8; 32] = input[offset].to_be_bytes();\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n\n    sha256_to_field(hash_input_flattened)\n}\n\n// Computes the final logs hash for a tx.\npub fn compute_tx_logs_hash<let N: u32>(logs: [LogHash; N]) -> Field {\n    // Convert each field element into a byte array and append the bytes to `hash_input_flattened`\n    let mut hash_input_flattened = [0; N * 32];\n    for offset in 0..N {\n        // TODO: This is not checking that the decomposition is smaller than P\n        let input_as_bytes: [u8; 32] = logs[offset].value.to_be_radix(256);\n        for byte_index in 0..32 {\n            hash_input_flattened[offset * 32 + byte_index] = input_as_bytes[byte_index];\n        }\n    }\n    // Ideally we would push to a slice then hash, but there is no sha_slice\n    // Hardcode to 256 bytes for now\n    let mut hash = sha256_to_field(hash_input_flattened);\n    // Not having a 0 value hash for empty logs causes issues with empty txs\n    // used for padding. Returning early is currently unsupported.\n    // We always provide sorted logs here, so 0 being empty means all are empty.\n    if is_empty(logs[0]) {\n        hash = 0;\n    }\n    hash\n}\n\npub fn verification_key_hash<let N: u32>(key: [Field; N]) -> Field {\n    crate::hash::poseidon2_hash(key)\n}\n\n#[inline_always]\npub fn pedersen_hash<let N: u32>(inputs: [Field; N], hash_index: u32) -> Field {\n    std::hash::pedersen_hash_with_separator(inputs, hash_index)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    std::hash::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = array_concat([separator.to_field()], inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n// Performs a fixed length hash with a subarray of the given input.\n// Useful for SpongeBlob in which we aborb M things and want to check it vs a hash of M elts of an N-len array.\n// Using stdlib poseidon, this will always absorb an extra 1 as a 'variable' hash, and not match spongeblob.squeeze()\n// or any ts implementation. Also checks that any remaining elts not hashed are empty.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, false);\n    sponge.squeeze()\n}\n\n// NB the below is the same as std::hash::poseidon2::Poseidon2::hash(), but replacing a range check with a bit check,\n// and absorbing in chunks of 3 below.\n#[no_predicates]\npub fn poseidon2_cheaper_variable_hash<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_chunks(input, in_len, true);\n    // In the case where the hash preimage is variable-length, we append `1` to the end of the input, to distinguish\n    // from fixed-length hashes. (the combination of this additional field element + the hash IV ensures\n    // fixed-length and variable-length hashes do not collide)\n    if in_len != N {\n        sponge.absorb(1);\n    }\n    sponge.squeeze()\n}\n\n// The below fn reduces gates of a conditional poseidon2 hash by approx 3x (thank you ~* Giant Brain Dev @IlyasRidhuan *~ for the idea)\n// Why? Because when we call stdlib poseidon, we call absorb for each item. When absorbing is conditional, it seems the compiler does not know\n// what cache_size will be when calling absorb, so it assigns the permutation gates for /each i/ rather than /every 3rd i/, which is actually required.\n// The below code forces the compiler to:\n//  - absorb normally up to 2 times to set cache_size to 1\n//  - absorb in chunks of 3 to ensure perm. only happens every 3rd absorb\n//  - absorb normally up to 2 times to add any remaining values to the hash\n// In fixed len hashes, the compiler is able to tell that it will only need to perform the permutation every 3 absorbs.\n// NB: it also replaces unnecessary range checks (i < thing) with a bit check (&= i != thing), which alone reduces the gates of a var. hash by half.\n\n#[no_predicates]\nfn poseidon2_absorb_chunks<let N: u32>(\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n) -> Poseidon2Sponge {\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    // Even though shift is always 1 here, if we input in_len = 0 we get an underflow\n    // since we cannot isolate computation branches. The below is just to avoid that.\n    let shift = if in_len == 0 { 0 } else { 1 };\n    if in_len != 0 {\n        // cache_size = 0, init absorb\n        sponge.cache[0] = input[0];\n        sponge.cache_size = 1;\n        // shift = num elts already added to make cache_size 1 = 1 for a fresh sponge\n        // M = max_chunks = (N - 1 - (N - 1) % 3) / 3: (must be written as a fn of N to compile)\n        // max_remainder = (N - 1) % 3;\n        // max_chunks = (N - 1 - max_remainder) / 3;\n        sponge = poseidon2_absorb_chunks_loop::<N, (N - 1 - (N - 1) % 3) / 3>(\n            sponge,\n            input,\n            in_len,\n            variable,\n            shift,\n        );\n    }\n    sponge\n}\n\n// NB: If it's not required to check that the non-absorbed elts of 'input' are 0s, set skip_0_check=true\n#[no_predicates]\npub fn poseidon2_absorb_chunks_existing_sponge<let N: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    skip_0_check: bool,\n) -> Poseidon2Sponge {\n    let mut sponge = in_sponge;\n    // 'shift' is to account for already added inputs\n    let mut shift = 0;\n    // 'stop' is to avoid an underflow when inputting in_len = 0\n    let mut stop = false;\n    for i in 0..3 {\n        if shift == in_len {\n            stop = true;\n        }\n        if (sponge.cache_size != 1) & (!stop) {\n            sponge.absorb(input[i]);\n            shift += 1;\n        }\n    }\n    sponge = if stop {\n        sponge\n    } else {\n        // max_chunks = (N - (N % 3)) / 3;\n        poseidon2_absorb_chunks_loop::<N, (N - (N % 3)) / 3>(\n            sponge,\n            input,\n            in_len,\n            skip_0_check,\n            shift,\n        )\n    };\n    sponge\n}\n\n// The below is the loop to absorb elts into a poseidon sponge in chunks of 3\n// shift - the num of elts already absorbed to ensure the sponge's cache_size = 1\n// M - the max number of chunks required to absorb N things (must be comptime to compile)\n// NB: The 0 checks ('Found non-zero field...') are messy, but having a separate loop over N to check\n// for 0s costs 3N gates. Current approach is approx 2N gates.\n#[no_predicates]\nfn poseidon2_absorb_chunks_loop<let N: u32, let M: u32>(\n    in_sponge: Poseidon2Sponge,\n    input: [Field; N],\n    in_len: u32,\n    variable: bool,\n    shift: u32,\n) -> Poseidon2Sponge {\n    assert(in_len <= N, \"Given in_len to absorb is larger than the input array len\");\n    // When we have an existing sponge, we may have a shift of 0, and the final 'k+2' below = N\n    // The below avoids an overflow\n    let skip_last = 3 * M == N;\n    // Writing in_sponge: &mut does not compile\n    let mut sponge = in_sponge;\n    let mut should_add = true;\n    // The num of things left over after absorbing in 3s\n    let remainder = (in_len - shift) % 3;\n    // The num of chunks of 3 to absorb (maximum M)\n    let chunks = (in_len - shift - remainder) / 3;\n    for i in 0..M {\n        // Now we loop through cache size = 1 -> 3\n        should_add &= i != chunks;\n        // This is the index at the start of the chunk (for readability)\n        let k = 3 * i + shift;\n        if should_add {\n            // cache_size = 1, 2 => just assign\n            sponge.cache[1] = input[k];\n            sponge.cache[2] = input[k + 1];\n            // cache_size = 3 => duplex + perm\n            for j in 0..3 {\n                sponge.state[j] += sponge.cache[j];\n            }\n            sponge.state = std::hash::poseidon2_permutation(sponge.state, 4);\n            sponge.cache[0] = input[k + 2];\n            // cache_size is now 1 again, repeat loop\n        } else if (!variable) & (i != chunks) {\n            // if we are hashing a fixed len array which is a subarray, we check the remaining elts are 0\n            // NB: we don't check at i == chunks, because that chunk contains elts to be absorbed or checked below\n            let last_0 = if (i == M - 1) & (skip_last) {\n                0\n            } else {\n                input[k + 2]\n            };\n            let all_0 = (input[k] == 0) & (input[k + 1] == 0) & (last_0 == 0);\n            assert(all_0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    // we have 'remainder' num of items left to absorb\n    should_add = true;\n    // below is to avoid overflows (i.e. if inlen is close to N)\n    let mut should_check = !variable;\n    for i in 0..3 {\n        should_add &= i != remainder;\n        should_check &= in_len - remainder + i != N;\n        if should_add {\n            // we want to absorb the final 'remainder' items\n            sponge.absorb(input[in_len - remainder + i]);\n        } else if should_check {\n            assert(input[in_len - remainder + i] == 0, \"Found non-zero field after breakpoint\");\n        }\n    }\n    sponge\n}\n\npub fn poseidon2_hash_with_separator_slice<T>(inputs: [Field], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs[i]);\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let sub_chunk_hash = poseidon2_hash_subarray(input, in_len);\n    let fixed_len_hash = std::hash::poseidon2::Poseidon2::hash(fixed_input, fixed_input.len());\n    assert(sub_chunk_hash == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_matches_variable() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    let variable_chunk_hash = poseidon2_cheaper_variable_hash(input, in_len);\n    let variable_len_hash = std::hash::poseidon2::Poseidon2::hash(input, in_len);\n    assert(variable_chunk_hash == variable_len_hash);\n}\n\n#[test]\nfn existing_sponge_poseidon_chunks_matches_fixed() {\n    let in_len = 501;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut fixed_input = [3; 501];\n    assert(in_len == fixed_input.len()); // sanity check\n    for i in 0..in_len {\n        input[i] = 3;\n    }\n    // absorb 250 of the 501 things\n    let empty_sponge = Poseidon2Sponge::new((in_len as Field) * TWO_POW_64);\n    let first_sponge = poseidon2_absorb_chunks_existing_sponge(empty_sponge, input, 250, true);\n    // now absorb the final 251 (since they are all 3s, im being lazy and not making a new array)\n    let mut final_sponge = poseidon2_absorb_chunks_existing_sponge(first_sponge, input, 251, true);\n    let fixed_len_hash = Poseidon2Sponge::hash(fixed_input, fixed_input.len());\n    assert(final_sponge.squeeze() == fixed_len_hash);\n}\n\n#[test]\nfn poseidon_chunks_empty_inputs() {\n    let in_len = 0;\n    let mut input: [Field; 4096] = [0; 4096];\n    let mut constructed_empty_sponge = poseidon2_absorb_chunks(input, in_len, true);\n    let mut first_sponge =\n        poseidon2_absorb_chunks_existing_sponge(constructed_empty_sponge, input, in_len, true);\n    assert(first_sponge.squeeze() == constructed_empty_sponge.squeeze());\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn compute_l2_l1_hash() {\n    // All zeroes\n    let hash_result =\n        compute_l2_to_l1_hash(AztecAddress::from_field(0), EthAddress::zero(), 0, 0, 0);\n    assert(hash_result == 0xb393978842a0fa3d3e1470196f098f473f9678e72463cb65ec4ab5581856c2);\n\n    // Non-zero case\n    let hash_result = compute_l2_to_l1_hash(\n        AztecAddress::from_field(1),\n        EthAddress::from_field(3),\n        5,\n        2,\n        4,\n    );\n    assert(hash_result == 0x3f88c1044a05e5340ed20466276500f6d45ca5603913b9091e957161734e16);\n}\n\n#[test]\nfn silo_l2_to_l1_message_matches_typescript() {\n    let version = 4;\n    let chainId = 5;\n\n    let hash = silo_l2_to_l1_message(\n        ScopedL2ToL1Message {\n            message: L2ToL1Message { recipient: EthAddress::from_field(1), content: 2, counter: 0 },\n            contract_address: AztecAddress::from_field(3),\n        },\n        version,\n        chainId,\n    );\n\n    // The following value was generated by `l2_to_l1_message.test.ts`\n    let hash_from_typescript = 0x00c6155d69febb9d5039b374dd4f77bf57b7c881709aa524a18acaa0bd57476a;\n\n    assert_eq(hash, hash_from_typescript);\n}\n"
     },
-    "269": {
+    "268": {
       "path": "/build-volume/noir-projects/noir-protocol-circuits/crates/types/src/indexed_tagging_secret.nr",
       "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"
     },
@@ -6007,37 +6005,37 @@
       "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"
     },
-    "284": {
+    "283": {
       "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, 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"
     },
-    "285": {
+    "284": {
       "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"
     },
-    "294": {
+    "293": {
       "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"
     },
-    "331": {
+    "330": {
       "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\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"
     },
-    "334": {
+    "333": {
       "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"
     },
-    "339": {
+    "338": {
       "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"
     },
-    "345": {
+    "344": {
       "path": "/root/nargo/github.com/noir-lang/sha256/v0.1.0/src/sha256.nr",
       "source": "use std::hash::sha256_compression;\nuse std::runtime::is_unconstrained;\n\nmod tests;\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// 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        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        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    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\n"
     },
-    "346": {
+    "345": {
       "path": "/build-volume/noir-projects/noir-contracts/contracts/ecdsa_public_key_note/src/lib.nr",
-      "source": "use dep::aztec::prelude::{NoteHeader, NoteInterface, NullifiableNote, PrivateContext};\n\nuse dep::aztec::{\n    note::utils::compute_note_hash_for_nullify, keys::getters::{get_nsk_app, get_public_keys},\n    protocol_types::{address::AztecAddress, constants::GENERATOR_INDEX__NOTE_NULLIFIER, hash::poseidon2_hash_with_separator},\n    macros::notes::note_custom_interface, generators::Ga1 as Gx_1, generators::Ga2 as Gx_2,\n    generators::Ga3 as Gy_1, generators::Ga4 as Gy_2, generators::Ga5 as G_owner, generators::G_slot\n};\n\nuse std::hash::from_field_unsafe;\n\nglobal ECDSA_PUBLIC_KEY_NOTE_LEN: u32 = 5;\n\n// Stores an ECDSA public key composed of two 32-byte elements\n// TODO: Do we need to include a nonce, in case we want to read/nullify/recreate with the same pubkey value?\n#[note_custom_interface]\npub struct EcdsaPublicKeyNote {\n    x: [u8; 32],\n    y: [u8; 32],\n    owner: AztecAddress,\n}\n\nimpl NoteInterface<ECDSA_PUBLIC_KEY_NOTE_LEN> for EcdsaPublicKeyNote {\n    // Cannot use the automatic packing since x and y don't fit. Pack the note as 5 fields where:\n    // [0] = x[0..31] (upper bound excluded)\n    // [1] = x[31]\n    // [2] = y[0..31]\n    // [3] = y[31]\n    // [4] = owner\n    fn pack_content(self) -> [Field; ECDSA_PUBLIC_KEY_NOTE_LEN] {\n        let mut x: Field = 0;\n        let mut y: Field = 0;\n        let mut mul: Field = 1;\n\n        for i in 1..32 {\n            let byte_x: Field = self.x[31 - i] as Field;\n            x = x + (byte_x * mul);\n            let byte_y: Field = self.y[31 - i] as Field;\n            y = y + (byte_y * mul);\n            mul *= 256;\n        }\n\n        let last_x = self.x[31] as Field;\n        let last_y = self.y[31] as Field;\n\n        [x, last_x, y, last_y, self.owner.to_field()]\n    }\n\n    // Cannot use the automatic unpacking for the aforementioned reasons\n    fn unpack_content(packed_content: [Field; ECDSA_PUBLIC_KEY_NOTE_LEN]) -> EcdsaPublicKeyNote {\n        let mut x: [u8; 32] = [0; 32];\n        let mut y: [u8; 32] = [0; 32];\n\n        let part_x:[u8; 32] = packed_content[0].to_be_bytes();\n        for i in 0..31 {\n            x[i] = part_x[i + 1];\n        }\n        x[31] = packed_content[1].to_be_bytes::<32>()[31];\n\n        let part_y:[u8; 32] = packed_content[2].to_be_bytes();\n        for i in 0..31 {\n            y[i] = part_y[i + 1];\n        }\n        y[31] = packed_content[3].to_be_bytes::<32>()[31];\n\n        EcdsaPublicKeyNote { x, y, owner: AztecAddress::from_field(packed_content[4]), header: NoteHeader::empty() }\n    }\n\n    fn get_note_type_id() -> Field {\n        // randomly chosen note type id --> has to fit within 7 bits\n        76\n    }\n\n    fn get_header(self) -> NoteHeader {\n        self.header\n    }\n\n    fn set_header(&mut self, header: NoteHeader) {\n        self.header = header;\n    }\n\n    fn compute_note_hash(self) -> Field {\n        let packed_content = self.pack_content();\n        std::embedded_curve_ops::multi_scalar_mul(\n            [Gx_1, Gx_2, Gy_1, Gy_2, G_owner, G_slot],\n            [\n            from_field_unsafe(packed_content[0]),\n            from_field_unsafe(packed_content[1]),\n            from_field_unsafe(packed_content[2]),\n            from_field_unsafe(packed_content[3]),\n            from_field_unsafe(packed_content[4]),\n            from_field_unsafe(self.get_header().storage_slot)\n        ]\n        ).x\n    }\n}\n\nimpl NullifiableNote for EcdsaPublicKeyNote {\n\n    fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field {\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = context.request_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n\n    unconstrained fn compute_nullifier_without_context(self) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_nullify(self);\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = get_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n}\n\nimpl EcdsaPublicKeyNote {\n    pub fn new(x: [u8; 32], y: [u8; 32], owner: AztecAddress) -> Self {\n        EcdsaPublicKeyNote { x, y, owner, header: NoteHeader::empty() }\n    }\n}\n"
+      "source": "use dep::aztec::prelude::{NoteHeader, NoteInterface, NullifiableNote, PrivateContext};\n\nuse dep::aztec::{\n    note::utils::compute_note_hash_for_nullify, keys::getters::{get_nsk_app, get_public_keys},\n    protocol_types::{address::AztecAddress, constants::{GENERATOR_INDEX__NOTE_NULLIFIER, GENERATOR_INDEX__NOTE_HASH}, hash::poseidon2_hash_with_separator},\n    macros::notes::note_custom_interface\n};\n\nglobal ECDSA_PUBLIC_KEY_NOTE_LEN: u32 = 5;\n\n// Stores an ECDSA public key composed of two 32-byte elements\n// TODO: Do we need to include a nonce, in case we want to read/nullify/recreate with the same pubkey value?\n#[note_custom_interface]\npub struct EcdsaPublicKeyNote {\n    x: [u8; 32],\n    y: [u8; 32],\n    owner: AztecAddress,\n}\n\nimpl NoteInterface<ECDSA_PUBLIC_KEY_NOTE_LEN> for EcdsaPublicKeyNote {\n    // Cannot use the automatic packing since x and y don't fit. Pack the note as 5 fields where:\n    // [0] = x[0..31] (upper bound excluded)\n    // [1] = x[31]\n    // [2] = y[0..31]\n    // [3] = y[31]\n    // [4] = owner\n    fn pack_content(self) -> [Field; ECDSA_PUBLIC_KEY_NOTE_LEN] {\n        let mut x: Field = 0;\n        let mut y: Field = 0;\n        let mut mul: Field = 1;\n\n        for i in 1..32 {\n            let byte_x: Field = self.x[31 - i] as Field;\n            x = x + (byte_x * mul);\n            let byte_y: Field = self.y[31 - i] as Field;\n            y = y + (byte_y * mul);\n            mul *= 256;\n        }\n\n        let last_x = self.x[31] as Field;\n        let last_y = self.y[31] as Field;\n\n        [x, last_x, y, last_y, self.owner.to_field()]\n    }\n\n    // Cannot use the automatic unpacking for the aforementioned reasons\n    fn unpack_content(packed_content: [Field; ECDSA_PUBLIC_KEY_NOTE_LEN]) -> EcdsaPublicKeyNote {\n        let mut x: [u8; 32] = [0; 32];\n        let mut y: [u8; 32] = [0; 32];\n\n        let part_x:[u8; 32] = packed_content[0].to_be_bytes();\n        for i in 0..31 {\n            x[i] = part_x[i + 1];\n        }\n        x[31] = packed_content[1].to_be_bytes::<32>()[31];\n\n        let part_y:[u8; 32] = packed_content[2].to_be_bytes();\n        for i in 0..31 {\n            y[i] = part_y[i + 1];\n        }\n        y[31] = packed_content[3].to_be_bytes::<32>()[31];\n\n        EcdsaPublicKeyNote { x, y, owner: AztecAddress::from_field(packed_content[4]), header: NoteHeader::empty() }\n    }\n\n    fn get_note_type_id() -> Field {\n        // randomly chosen note type id --> has to fit within 7 bits\n        76\n    }\n\n    fn get_header(self) -> NoteHeader {\n        self.header\n    }\n\n    fn set_header(&mut self, header: NoteHeader) {\n        self.header = header;\n    }\n\n    fn compute_note_hash(self) -> Field {\n        // We use Poseidon2 instead of multi-scalar multiplication (MSM) here since this is not a partial note\n        // and therefore does not require MSM's additive homomorphism property. Additionally, Poseidon2 uses fewer\n        // constraints.\n        poseidon2_hash_with_separator(self.pack_content(), GENERATOR_INDEX__NOTE_HASH)\n    }\n}\n\nimpl NullifiableNote for EcdsaPublicKeyNote {\n\n    fn compute_nullifier(self, context: &mut PrivateContext, note_hash_for_nullify: Field) -> Field {\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = context.request_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n\n    unconstrained fn compute_nullifier_without_context(self) -> Field {\n        let note_hash_for_nullify = compute_note_hash_for_nullify(self);\n        let owner_npk_m_hash = get_public_keys(self.owner).npk_m.hash();\n        let secret = get_nsk_app(owner_npk_m_hash);\n        poseidon2_hash_with_separator(\n            [\n            note_hash_for_nullify,\n            secret\n        ],\n            GENERATOR_INDEX__NOTE_NULLIFIER as Field\n        )\n    }\n}\n\nimpl EcdsaPublicKeyNote {\n    pub fn new(x: [u8; 32], y: [u8; 32], owner: AztecAddress) -> Self {\n        EcdsaPublicKeyNote { x, y, owner, header: NoteHeader::empty() }\n    }\n}\n"
     },
     "51": {
       "path": "std/option.nr",
@@ -6093,9 +6091,9 @@
     },
     "88": {
       "path": "/build-volume/noir-projects/aztec-nr/aztec/src/encrypted_logs/log_assembly_strategies/default_aes128/note.nr",
-      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n    keys::{\n        ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        ephemeral::generate_ephemeral_key_pair,\n    },\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::{be_bytes_31_to_fields, get_random_bytes}, point::get_sign_of_point},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n};\nuse std::aes128::aes128_encrypt;\n\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 48; // contract_address (32) + ciphertext_length (2) + 16 bytes pkcs#7 AES padding.\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n * Note-specific:\n * derive_note_randomness_from_shared_secret: false\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * Short explanation:\n * log = [tag, epk, header_ct=[[contract_address, ct_len], pkcs7_pad], ct=[[pt], pkcs7_pad], some bytes padding, some fields padding]\n *\n * Long explanation:\n * tag: Field\n * epk: [Field, u8]\n * header_ct: [[u8; 32], [u8; 2], [u8; 16]]\n * ct: [[u8; 2], [u8; x], [u8; y]]\n *\n * More precisely (in pseudocode):\n *\n * log = [\n *     tag: Field,\n *     Epk: Field,\n *\n *     le_bytes_31_to_fields(\n *\n *         log_bytes: [\n *             eph_pk_sign: [u8; 1],\n *\n *             header_ciphertext: aes_encrypt(\n *                 contract_address: [u8; 32],\n *                 ct_length: [u8; 2],\n *\n *                 // the aes128_encrypt fn automatically inserts padding:\n *                 header_pt_aes_padding: [u8; 14], // `16 - (input.len() % 16)`\n\n *             ): [u8; 48],\n *\n *             ciphertext: aes_encrypt(\n *                 final_pt: [\n *                     pt: {\n *                         note_bytes: {\n *                             storage_slot: [u8; 32],\n *                             note_type_id: [u8; 32],\n *                             ...note: [u8; N * 32],\n *                         }: [u8; N * 32 + 64],\n *                     }: [u8; N * 32 + 64],\n\n *                 ]: [u8; N * 32 + 64],\n *\n *                 // the aes128_encrypt fn automatically inserts padding:\n *                 pt_aes_padding: [u8; 16 - ( (|pt_length| + |pt|) % 16 )]\n *\n *             ): [u8; |pt| + |pt_aes_padding|]\n *                [u8; |ct|]\n *\n *             log_bytes_padding_to_mult_31: [u8; 31 * ceil((1 + 48 + |ct|)/31) - (1 + 48 + |ct|)],\n *                                           [u8; p]\n *\n *         ]: [u8; 1 + 48 + |ct| + p]\n *\n *     ): [Field; (1 + 48 + |ct| + p) / 31]\n *\n *     log_fields_padding: [Field; PRIVATE_LOG_SIZE_IN_FIELDS - 2 - (1 + 48 + |ct| + p) / 31],\n *\n * ]: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\n *\n *\n */\n\n/********************************************************/\n// Disgusting arithmetic on generics\n/********************************************************/\n\n// In this section, instead of initialising arrays with very complicated generic\n// arithmetic, such as:\n// let my_arr: [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] = [0; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))];\n//... we instead do the arithmetic a little bit at a time, so that the computation\n// can be audited and understood. Now, we can't do arithmetic on generics in the body\n// of a function, so we abusing functions in the following way:\n\n// |full_pt| = |pt| = (N * 32) + 64\nfn get_arr_of_size__full_plaintext<let PT: u32>() -> [u8; PT] {\n    [0; PT]\n}\n\n// |pt_aes_padding| = 16 - (|full_pt| % 16)\nfn get_arr_of_size__plaintext_aes_padding<let FULL_PT: u32>(\n    _full_pt: [u8; FULL_PT],\n) -> [u8; 16 - (FULL_PT % 16)] {\n    [0; 16 - (FULL_PT % 16)]\n}\n\n// |ct| = |full_pt| + |pt_aes_padding|\nfn get_arr_of_size__ciphertext<let FULL_PT: u32, let PT_AES_PADDING: u32>(\n    _full_pt: [u8; FULL_PT],\n    _pt_aes_padding: [u8; PT_AES_PADDING],\n) -> [u8; FULL_PT + PT_AES_PADDING] {\n    [0; FULL_PT + PT_AES_PADDING]\n}\n\n// Ok, so we have the following bytes:\n// eph_pk_sign, header_ciphertext, ciphertext:\n// Let lbwop = 1 + 48 + |ct| // aka log bytes without padding\nfn get_arr_of_size__log_bytes_without_padding<let CT: u32>(_ct: [u8; CT]) -> [u8; 1 + 48 + CT] {\n    [0; 1 + 48 + CT]\n}\n\n// Recall:\n//   lbwop := 1 + 48 + |ct| // aka log bytes without padding\n// We now want to pad b to the next multiple of 31, so as to \"fill\" fields.\n// Let p be that padding.\n// p = 31 * ceil(lbwop / 31) - lbwop\n//   = 31 * ((lbwop + 30) // 31) - lbwop\n//     (because ceil(x / y) = (x + y - 1) // y ).\nfn get_arr_of_size__log_bytes_padding<let LBWOP: u32>(\n    _lbwop: [u8; LBWOP],\n) -> [u8; (31 * ((LBWOP + 30) / 31)) - LBWOP] {\n    [0; (31 * ((LBWOP + 30) / 31)) - LBWOP]\n}\n\n// |log_bytes| = 1 + 48 + |ct| + p // aka log bytes (with padding)\n// Recall:\n//   lbwop := 1 + 48 + |ct|\n//   p is the padding\nfn get_arr_of_size__log_bytes<let LBWOP: u32, let P: u32>(\n    _lbwop: [u8; LBWOP],\n    _p: [u8; P],\n) -> [u8; LBWOP + P] {\n    [0; LBWOP + P]\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\n// PT is the plaintext length.\npub(crate) fn get_arr_of_size__log_bytes_padding__from_PT<let PT: u32>() -> [u8; ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49))] {\n    let full_pt = get_arr_of_size__full_plaintext::<PT>();\n    let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n    let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n    let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n    let p = get_arr_of_size__log_bytes_padding(lbwop);\n    p\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\npub(crate) fn get_arr_of_size__log_bytes__from_PT<let PT: u32>() -> [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] {\n    let full_pt = get_arr_of_size__full_plaintext::<PT>();\n    let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n    let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n    let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n    let p = get_arr_of_size__log_bytes_padding(lbwop);\n    let log_bytes = get_arr_of_size__log_bytes(lbwop, p);\n    log_bytes\n}\n\n/********************************************************/\n// End of disgusting arithmetic on generics\n/********************************************************/\n\n// TODO: it feels like this existence check is in the wrong place. In fact, why is it needed at all? Under what circumstances have we found a non-existent note being emitted accidentally?\nfn assert_note_exists<Note, let N: u32>(context: PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\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\n/// This particular log assembly strategy (AES 128) requires the note (and the\n/// note_id and the storage_slot) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The extra `+ 64` bytes is for the note_id and the storage_slot of the note:\nfn compute_note_plaintext_for_this_strategy<Note, let N: u32>(note: Note) -> [u8; N * 32 + 64]\nwhere\n    Note: NoteInterface<N>,\n{\n    let packed_note = note.pack_content();\n\n    let note_header = note.get_header();\n    let storage_slot = note_header.storage_slot;\n    let storage_slot_bytes: [u8; 32] = storage_slot.to_be_bytes();\n\n    // TODO(#10952): The following can be reduced to 7 bits\n    let note_type_id_bytes: [u8; 32] = Note::get_note_type_id().to_be_bytes();\n\n    // We combine all the bytes into plaintext_bytes:\n    let mut plaintext_bytes: [u8; N * 32 + 64] = [0; N * 32 + 64];\n    for i in 0..32 {\n        plaintext_bytes[i] = storage_slot_bytes[i];\n        plaintext_bytes[32 + i] = note_type_id_bytes[i];\n    }\n\n    for i in 0..packed_note.len() {\n        let bytes: [u8; 32] = packed_note[i].to_be_bytes();\n        for j in 0..32 {\n            plaintext_bytes[64 + i * 32 + j] = bytes[j];\n        }\n    }\n\n    plaintext_bytes\n}\n\nfn compute_log<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n    Note: NoteInterface<N>,\n{\n    // *****************************************************************************\n    // Compute the shared secret\n    // *****************************************************************************\n\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n    let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient); // not to be confused with the tagging shared secret\n\n    // TODO: also use this shared secret for deriving note randomness.\n\n    // *****************************************************************************\n    // Compute the plaintext\n    // *****************************************************************************\n\n    let final_plaintext_bytes = compute_note_plaintext_for_this_strategy(note);\n\n    // *****************************************************************************\n    // Convert the plaintext into whatever format the encryption function expects\n    // *****************************************************************************\n\n    // Already done for this strategy: AES expects bytes.\n\n    // *****************************************************************************\n    // Encrypt the plaintext\n    // *****************************************************************************\n\n    let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n        ciphertext_shared_secret,\n    );\n\n    let ciphertext_bytes = aes128_encrypt(final_plaintext_bytes, iv, sym_key);\n\n    // |full_pt| = |pt_length| + |pt|\n    // |pt_aes_padding| = 16 - (|full_pt| % 16)\n    // or... since a % b is the same as a - b * (a // b) (integer division), so:\n    // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n    // |ct| = |full_pt| + |pt_aes_padding|\n    //      = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n    //      = 16 + 16 * (|full_pt| // 16)\n    //      = 16 * (1 + |full_pt| // 16)\n    assert(ciphertext_bytes.len() == 16 * (1 + ((N * 32) + 64) / 16));\n\n    // *****************************************************************************\n    // Compute the header ciphertext\n    // *****************************************************************************\n\n    let contract_address = context.this_address();\n    let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n    let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n    for i in 0..32 {\n        header_plaintext[i] = contract_address_bytes[i];\n    }\n    let offset = 32;\n    let ciphertext_bytes_length = ciphertext_bytes.len();\n    header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n    header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n    // TODO: this is insecure and wasteful:\n    // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n    // and again for the proper ciphertext) (at least, I never got the\n    // \"go ahead\" that this would be safe, unfortunately).\n    // \"Wasteful\", because the exact same computation is happening further down.\n    // I'm leaving that 2nd computation where it is, because this 1st computation\n    // will be imminently deleted, when the header logic is deleted.\n    let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n        ciphertext_shared_secret,\n    );\n\n    // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n    // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n    // bytes larger than the input in this case.\n    let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n    // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n    assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n    // *****************************************************************************\n    // Prepend / append more bytes of data to the ciphertext, before converting back\n    // to fields.\n    // *****************************************************************************\n\n    let mut log_bytes_padding_to_mult_31 =\n        get_arr_of_size__log_bytes_padding__from_PT::<(N * 32) + 64>();\n    /// Safety: this randomness won't be constrained to be random. It's in the\n    /// interest of the executor of this fn to encrypt with random bytes.\n    log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n    let mut log_bytes = get_arr_of_size__log_bytes__from_PT::<(N * 32) + 64>();\n\n    assert(\n        log_bytes.len() % 31 == 0,\n        \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n    );\n\n    log_bytes[0] = eph_pk_sign_byte;\n    let mut offset = 1;\n    for i in 0..header_ciphertext_bytes.len() {\n        log_bytes[offset + i] = header_ciphertext_bytes[i];\n    }\n    offset += header_ciphertext_bytes.len();\n\n    for i in 0..ciphertext_bytes.len() {\n        log_bytes[offset + i] = ciphertext_bytes[i];\n    }\n    offset += ciphertext_bytes.len();\n\n    for i in 0..log_bytes_padding_to_mult_31.len() {\n        log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n    }\n\n    assert(\n        offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n        \"Something has gone wrong\",\n    );\n\n    // *****************************************************************************\n    // Convert bytes back to fields\n    // *****************************************************************************\n\n    let log_bytes_as_fields = be_bytes_31_to_fields(log_bytes);\n\n    // *****************************************************************************\n    // Prepend / append fields, to create the final log\n    // *****************************************************************************\n\n    // In this strategy, we prepend [tag, eph_pk.x]\n\n    // We assume that the sender wants for the recipient to find the tagged note,\n    // and therefore that they will cooperate and use the correct tag. Usage of a bad\n    // tag will result in the recipient not being able to 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    let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n    final_log[0] = tag;\n    final_log[1] = eph_pk.x;\n\n    let mut offset = 2;\n    for i in 0..log_bytes_as_fields.len() {\n        final_log[offset + i] = log_bytes_as_fields[i];\n    }\n    offset += log_bytes_as_fields.len();\n\n    for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n        /// Safety: randomness cannot be constrained.\n        final_log[i] = unsafe { random() };\n    }\n\n    final_log\n}\n\nunconstrained fn compute_log_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n    Note: NoteInterface<N>,\n{\n    compute_log(context, note, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let note = e.note;\n        assert_note_exists(*context, note);\n\n        let note_hash_counter = note.get_header().note_hash_counter;\n\n        let encrypted_log = compute_log(*context, note, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\n// Important note: this function -- although called \"unconstrained\" -- the\n// function is not labelled as `unconstrained`, because we pass a reference to the\n// context.\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        let note = e.note;\n        assert_note_exists(*context, note);\n\n        let note_hash_counter = note.get_header().note_hash_counter;\n\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 = unsafe { compute_log_unconstrained(*context, note, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\nmod test {\n    use crate::test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote};\n    use dep::protocol_types::address::AztecAddress;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        let mut env = TestEnvironment::new();\n        // Advance 1 block so we can read historic state from private\n        env.advance_block_by(1);\n        let mut context = env.private();\n\n        // I'm not sure how to initialise an `env` or `context` with a consistent contract address for every run of this test; the value kept changing each time. So I'm going to overwrite it now:\n        context.inputs.call_context.contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        ); // This is an address copied to match the typescript one.\n\n        let storage_slot = 42;\n        let note = MockNote::new(1234)\n            .contract_address(context.this_address())\n            .storage_slot(storage_slot)\n            .build();\n        let contract_address = context.this_address();\n\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 = super::compute_note_plaintext_for_this_strategy(note);\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\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 = super::compute_log(context, note, recipient, sender);\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            0x0d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701fa7,\n            0x00010577790aeabcc2d81ec8d0c99e7f5d2bf2f1452025dc777a178404f851d9,\n            0x003de81cde78411f27a921e16ebbfba71a5570d3f62f1134c90daced33663ba0,\n            0x00856cb19c7d563da183a40a6f8bd4988d1696ad6bf0c717c8fb8f6294bd0366,\n            0x001ed04e4f77a111c7090fcd34c61cfae744e8589a42defba4d0d927dd4679fe,\n            0x00ec09b49d8d4cf548ea62d44c8839b2fd14664e9d1439b199a8d5166e362348,\n            0x004a69de2d410e01010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n}\n"
+      "source": "use crate::{\n    context::PrivateContext,\n    encrypted_logs::encrypt::aes128::derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256,\n    keys::{\n        ecdh_shared_secret::derive_ecdh_shared_secret_using_aztec_address,\n        ephemeral::generate_ephemeral_key_pair,\n    },\n    note::{note_emission::NoteEmission, note_interface::NoteInterface},\n    oracle::{\n        notes::{get_app_tag_as_sender, increment_app_tagging_secret_index_as_sender},\n        random::random,\n    },\n    utils::{bytes::{be_bytes_31_to_fields, get_random_bytes}, point::get_sign_of_point},\n};\nuse dep::protocol_types::{\n    abis::note_hash::NoteHash, address::AztecAddress, constants::PRIVATE_LOG_SIZE_IN_FIELDS,\n};\nuse std::aes128::aes128_encrypt;\n\npub(crate) global HEADER_CIPHERTEXT_SIZE_IN_BYTES: u32 = 48; // contract_address (32) + ciphertext_length (2) + 16 bytes pkcs#7 AES padding.\n\n/*\n * WHY IS THERE LOTS OF CODE DUPLICATION BETWEEN event.nr and note.nr?\n * It's because there are a few more optimisations that can be done for notes,\n * and so the stuff that looks like duplicated code currently, won't be\n * the same for long.\n * To modularise now feels premature, because we might get that modularisation wrong.\n * Much better (imo) to have a flattened templates for log assembly, because it\n * makes it much easier for us all to follow, it serves as a nice example for the\n * community to follow (if they wish to roll their own log layouts), and it gives\n * us more time to spot common patterns across all kinds of log layouts.\n */\n\n/*\n * LOG CONFIGURATION CHOICES:\n *\n * deliver_to: INPUT as recipient: AztecAddress\n * encrypt_with: aes128 CBC (Cipher Block Chaining)\n * shared_secret: ephemeral\n * shared_secret_randomness_extraction_hash: sha256\n * tag: true\n * tag_from: INPUT as sender: AztecAddress\n *\n * Note-specific:\n * derive_note_randomness_from_shared_secret: false\n *\n */\n\n/*\n * LOG LAYOUT CHOICE:\n *\n * Short explanation:\n * log = [tag, epk, header_ct=[[contract_address, ct_len], pkcs7_pad], ct=[[pt], pkcs7_pad], some bytes padding, some fields padding]\n *\n * Long explanation:\n * tag: Field\n * epk: [Field, u8]\n * header_ct: [[u8; 32], [u8; 2], [u8; 16]]\n * ct: [[u8; 2], [u8; x], [u8; y]]\n *\n * More precisely (in pseudocode):\n *\n * log = [\n *     tag: Field,\n *     Epk: Field,\n *\n *     le_bytes_31_to_fields(\n *\n *         log_bytes: [\n *             eph_pk_sign: [u8; 1],\n *\n *             header_ciphertext: aes_encrypt(\n *                 contract_address: [u8; 32],\n *                 ct_length: [u8; 2],\n *\n *                 // the aes128_encrypt fn automatically inserts padding:\n *                 header_pt_aes_padding: [u8; 14], // `16 - (input.len() % 16)`\n\n *             ): [u8; 48],\n *\n *             ciphertext: aes_encrypt(\n *                 final_pt: [\n *                     pt: {\n *                         note_bytes: {\n *                             storage_slot: [u8; 32],\n *                             note_type_id: [u8; 32],\n *                             ...note: [u8; N * 32],\n *                         }: [u8; N * 32 + 64],\n *                     }: [u8; N * 32 + 64],\n\n *                 ]: [u8; N * 32 + 64],\n *\n *                 // the aes128_encrypt fn automatically inserts padding:\n *                 pt_aes_padding: [u8; 16 - ( (|pt_length| + |pt|) % 16 )]\n *\n *             ): [u8; |pt| + |pt_aes_padding|]\n *                [u8; |ct|]\n *\n *             log_bytes_padding_to_mult_31: [u8; 31 * ceil((1 + 48 + |ct|)/31) - (1 + 48 + |ct|)],\n *                                           [u8; p]\n *\n *         ]: [u8; 1 + 48 + |ct| + p]\n *\n *     ): [Field; (1 + 48 + |ct| + p) / 31]\n *\n *     log_fields_padding: [Field; PRIVATE_LOG_SIZE_IN_FIELDS - 2 - (1 + 48 + |ct| + p) / 31],\n *\n * ]: [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\n *\n *\n */\n\n/********************************************************/\n// Disgusting arithmetic on generics\n/********************************************************/\n\n// In this section, instead of initialising arrays with very complicated generic\n// arithmetic, such as:\n// let my_arr: [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] = [0; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))];\n//... we instead do the arithmetic a little bit at a time, so that the computation\n// can be audited and understood. Now, we can't do arithmetic on generics in the body\n// of a function, so we abusing functions in the following way:\n\n// |full_pt| = |pt| = (N * 32) + 64\nfn get_arr_of_size__full_plaintext<let PT: u32>() -> [u8; PT] {\n    [0; PT]\n}\n\n// |pt_aes_padding| = 16 - (|full_pt| % 16)\nfn get_arr_of_size__plaintext_aes_padding<let FULL_PT: u32>(\n    _full_pt: [u8; FULL_PT],\n) -> [u8; 16 - (FULL_PT % 16)] {\n    [0; 16 - (FULL_PT % 16)]\n}\n\n// |ct| = |full_pt| + |pt_aes_padding|\nfn get_arr_of_size__ciphertext<let FULL_PT: u32, let PT_AES_PADDING: u32>(\n    _full_pt: [u8; FULL_PT],\n    _pt_aes_padding: [u8; PT_AES_PADDING],\n) -> [u8; FULL_PT + PT_AES_PADDING] {\n    [0; FULL_PT + PT_AES_PADDING]\n}\n\n// Ok, so we have the following bytes:\n// eph_pk_sign, header_ciphertext, ciphertext:\n// Let lbwop = 1 + 48 + |ct| // aka log bytes without padding\nfn get_arr_of_size__log_bytes_without_padding<let CT: u32>(_ct: [u8; CT]) -> [u8; 1 + 48 + CT] {\n    [0; 1 + 48 + CT]\n}\n\n// Recall:\n//   lbwop := 1 + 48 + |ct| // aka log bytes without padding\n// We now want to pad b to the next multiple of 31, so as to \"fill\" fields.\n// Let p be that padding.\n// p = 31 * ceil(lbwop / 31) - lbwop\n//   = 31 * ((lbwop + 30) // 31) - lbwop\n//     (because ceil(x / y) = (x + y - 1) // y ).\nfn get_arr_of_size__log_bytes_padding<let LBWOP: u32>(\n    _lbwop: [u8; LBWOP],\n) -> [u8; (31 * ((LBWOP + 30) / 31)) - LBWOP] {\n    [0; (31 * ((LBWOP + 30) / 31)) - LBWOP]\n}\n\n// |log_bytes| = 1 + 48 + |ct| + p // aka log bytes (with padding)\n// Recall:\n//   lbwop := 1 + 48 + |ct|\n//   p is the padding\nfn get_arr_of_size__log_bytes<let LBWOP: u32, let P: u32>(\n    _lbwop: [u8; LBWOP],\n    _p: [u8; P],\n) -> [u8; LBWOP + P] {\n    [0; LBWOP + P]\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\n// PT is the plaintext length.\npub(crate) fn get_arr_of_size__log_bytes_padding__from_PT<let PT: u32>() -> [u8; ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49))] {\n    let full_pt = get_arr_of_size__full_plaintext::<PT>();\n    let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n    let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n    let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n    let p = get_arr_of_size__log_bytes_padding(lbwop);\n    p\n}\n\n// The return type is pasted from the LSP's expectation, because it was too difficult\n// to match its weird way of doing algebra. It doesn't know all rules of arithmetic.\npub(crate) fn get_arr_of_size__log_bytes__from_PT<let PT: u32>() -> [u8; (((PT + (16 - (PT % 16))) + 49) + ((((((PT + (16 - (PT % 16))) + 49) + 30) / 31) * 31) - ((PT + (16 - (PT % 16))) + 49)))] {\n    let full_pt = get_arr_of_size__full_plaintext::<PT>();\n    let pt_aes_padding = get_arr_of_size__plaintext_aes_padding(full_pt);\n    let ct = get_arr_of_size__ciphertext(full_pt, pt_aes_padding);\n    let lbwop = get_arr_of_size__log_bytes_without_padding(ct);\n    let p = get_arr_of_size__log_bytes_padding(lbwop);\n    let log_bytes = get_arr_of_size__log_bytes(lbwop, p);\n    log_bytes\n}\n\n/********************************************************/\n// End of disgusting arithmetic on generics\n/********************************************************/\n\n// TODO: it feels like this existence check is in the wrong place. In fact, why is it needed at all? Under what circumstances have we found a non-existent note being emitted accidentally?\nfn assert_note_exists<Note, let N: u32>(context: PrivateContext, note: Note)\nwhere\n    Note: NoteInterface<N>,\n{\n    let note_header = note.get_header();\n    let note_hash_counter = note_header.note_hash_counter;\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\n/// This particular log assembly strategy (AES 128) requires the note (and the\n/// note_id and the storage_slot) to be converted into bytes, because the aes function\n/// operates on bytes; not fields.\n/// NB: The extra `+ 64` bytes is for the note_id and the storage_slot of the note:\nfn compute_note_plaintext_for_this_strategy<Note, let N: u32>(note: Note) -> [u8; N * 32 + 64]\nwhere\n    Note: NoteInterface<N>,\n{\n    let packed_note = note.pack_content();\n\n    let note_header = note.get_header();\n    let storage_slot = note_header.storage_slot;\n    let storage_slot_bytes: [u8; 32] = storage_slot.to_be_bytes();\n\n    // TODO(#10952): The following can be reduced to 7 bits\n    let note_type_id_bytes: [u8; 32] = Note::get_note_type_id().to_be_bytes();\n\n    // We combine all the bytes into plaintext_bytes:\n    let mut plaintext_bytes: [u8; N * 32 + 64] = [0; N * 32 + 64];\n    for i in 0..32 {\n        plaintext_bytes[i] = storage_slot_bytes[i];\n        plaintext_bytes[32 + i] = note_type_id_bytes[i];\n    }\n\n    for i in 0..packed_note.len() {\n        let bytes: [u8; 32] = packed_note[i].to_be_bytes();\n        for j in 0..32 {\n            plaintext_bytes[64 + i * 32 + j] = bytes[j];\n        }\n    }\n\n    plaintext_bytes\n}\n\nfn compute_log<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n    Note: NoteInterface<N>,\n{\n    // *****************************************************************************\n    // Compute the shared secret\n    // *****************************************************************************\n\n    let (eph_sk, eph_pk) = generate_ephemeral_key_pair();\n\n    let eph_pk_sign_byte: u8 = get_sign_of_point(eph_pk) as u8;\n\n    let ciphertext_shared_secret = derive_ecdh_shared_secret_using_aztec_address(eph_sk, recipient); // not to be confused with the tagging shared secret\n\n    // TODO: also use this shared secret for deriving note randomness.\n\n    // *****************************************************************************\n    // Compute the plaintext\n    // *****************************************************************************\n\n    let final_plaintext_bytes = compute_note_plaintext_for_this_strategy(note);\n\n    // *****************************************************************************\n    // Convert the plaintext into whatever format the encryption function expects\n    // *****************************************************************************\n\n    // Already done for this strategy: AES expects bytes.\n\n    // *****************************************************************************\n    // Encrypt the plaintext\n    // *****************************************************************************\n\n    let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n        ciphertext_shared_secret,\n    );\n\n    let ciphertext_bytes = aes128_encrypt(final_plaintext_bytes, iv, sym_key);\n\n    // |full_pt| = |pt_length| + |pt|\n    // |pt_aes_padding| = 16 - (|full_pt| % 16)\n    // or... since a % b is the same as a - b * (a // b) (integer division), so:\n    // |pt_aes_padding| = 16 - (|full_pt| - 16 * (|full_pt| // 16))\n    // |ct| = |full_pt| + |pt_aes_padding|\n    //      = |full_pt| + 16 - (|full_pt| - 16 * (|full_pt| // 16))\n    //      = 16 + 16 * (|full_pt| // 16)\n    //      = 16 * (1 + |full_pt| // 16)\n    assert(ciphertext_bytes.len() == 16 * (1 + ((N * 32) + 64) / 16));\n\n    // *****************************************************************************\n    // Compute the header ciphertext\n    // *****************************************************************************\n\n    let contract_address = context.this_address();\n    let contract_address_bytes = contract_address.to_field().to_be_bytes::<32>();\n\n    let mut header_plaintext: [u8; 32 + 2] = [0; 32 + 2];\n    for i in 0..32 {\n        header_plaintext[i] = contract_address_bytes[i];\n    }\n    let offset = 32;\n    let ciphertext_bytes_length = ciphertext_bytes.len();\n    header_plaintext[offset] = (ciphertext_bytes_length >> 8) as u8;\n    header_plaintext[offset + 1] = ciphertext_bytes_length as u8;\n\n    // TODO: this is insecure and wasteful:\n    // \"Insecure\", because the esk shouldn't be used twice (once for the header,\n    // and again for the proper ciphertext) (at least, I never got the\n    // \"go ahead\" that this would be safe, unfortunately).\n    // \"Wasteful\", because the exact same computation is happening further down.\n    // I'm leaving that 2nd computation where it is, because this 1st computation\n    // will be imminently deleted, when the header logic is deleted.\n    let (sym_key, iv) = derive_aes_symmetric_key_and_iv_from_ecdh_shared_secret_using_sha256(\n        ciphertext_shared_secret,\n    );\n\n    // Note: the aes128_encrypt builtin fn automatically appends bytes to the\n    // input, according to pkcs#7; hence why the output `header_ciphertext_bytes` is 16\n    // bytes larger than the input in this case.\n    let header_ciphertext_bytes = aes128_encrypt(header_plaintext, iv, sym_key);\n    // I recall that converting a slice to an array incurs constraints, so I'll check the length this way instead:\n    assert(header_ciphertext_bytes.len() == HEADER_CIPHERTEXT_SIZE_IN_BYTES);\n\n    // *****************************************************************************\n    // Prepend / append more bytes of data to the ciphertext, before converting back\n    // to fields.\n    // *****************************************************************************\n\n    let mut log_bytes_padding_to_mult_31 =\n        get_arr_of_size__log_bytes_padding__from_PT::<(N * 32) + 64>();\n    /// Safety: this randomness won't be constrained to be random. It's in the\n    /// interest of the executor of this fn to encrypt with random bytes.\n    log_bytes_padding_to_mult_31 = unsafe { get_random_bytes() };\n\n    let mut log_bytes = get_arr_of_size__log_bytes__from_PT::<(N * 32) + 64>();\n\n    assert(\n        log_bytes.len() % 31 == 0,\n        \"Unexpected error: log_bytes.len() should be divisible by 31, by construction.\",\n    );\n\n    log_bytes[0] = eph_pk_sign_byte;\n    let mut offset = 1;\n    for i in 0..header_ciphertext_bytes.len() {\n        log_bytes[offset + i] = header_ciphertext_bytes[i];\n    }\n    offset += header_ciphertext_bytes.len();\n\n    for i in 0..ciphertext_bytes.len() {\n        log_bytes[offset + i] = ciphertext_bytes[i];\n    }\n    offset += ciphertext_bytes.len();\n\n    for i in 0..log_bytes_padding_to_mult_31.len() {\n        log_bytes[offset + i] = log_bytes_padding_to_mult_31[i];\n    }\n\n    assert(\n        offset + log_bytes_padding_to_mult_31.len() == log_bytes.len(),\n        \"Something has gone wrong\",\n    );\n\n    // *****************************************************************************\n    // Convert bytes back to fields\n    // *****************************************************************************\n\n    let log_bytes_as_fields = be_bytes_31_to_fields(log_bytes);\n\n    // *****************************************************************************\n    // Prepend / append fields, to create the final log\n    // *****************************************************************************\n\n    // In this strategy, we prepend [tag, eph_pk.x]\n\n    // We assume that the sender wants for the recipient to find the tagged note,\n    // and therefore that they will cooperate and use the correct tag. Usage of a bad\n    // tag will result in the recipient not being able to 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    let mut final_log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS] = [0; PRIVATE_LOG_SIZE_IN_FIELDS];\n\n    final_log[0] = tag;\n    final_log[1] = eph_pk.x;\n\n    let mut offset = 2;\n    for i in 0..log_bytes_as_fields.len() {\n        final_log[offset + i] = log_bytes_as_fields[i];\n    }\n    offset += log_bytes_as_fields.len();\n\n    for i in offset..PRIVATE_LOG_SIZE_IN_FIELDS {\n        /// Safety: randomness cannot be constrained.\n        final_log[i] = unsafe { random() };\n    }\n\n    final_log\n}\n\nunconstrained fn compute_log_unconstrained<Note, let N: u32>(\n    context: PrivateContext,\n    note: Note,\n    recipient: AztecAddress,\n    sender: AztecAddress,\n) -> [Field; PRIVATE_LOG_SIZE_IN_FIELDS]\nwhere\n    Note: NoteInterface<N>,\n{\n    compute_log(context, note, recipient, sender)\n}\n\n// This function seems to be affected by the following Noir bug:\n// https://github.com/noir-lang/noir/issues/5771\n// If you get weird behavior it might be because of it.\npub fn encode_and_encrypt_note<Note, let N: u32>(\n    context: &mut PrivateContext,\n    recipient: AztecAddress,\n    // We need this because to compute a tagging secret, we require a sender:\n    sender: AztecAddress,\n) -> fn[(&mut PrivateContext, AztecAddress, AztecAddress)](NoteEmission<Note>) -> ()\nwhere\n    Note: NoteInterface<N>,\n{\n    |e: NoteEmission<Note>| {\n        let note = e.note;\n        assert_note_exists(*context, note);\n\n        let note_hash_counter = note.get_header().note_hash_counter;\n\n        let encrypted_log = compute_log(*context, note, recipient, sender);\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\n// Important note: this function -- although called \"unconstrained\" -- the\n// function is not labelled as `unconstrained`, because we pass a reference to the\n// context.\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        let note = e.note;\n        assert_note_exists(*context, note);\n\n        let note_hash_counter = note.get_header().note_hash_counter;\n\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 = unsafe { compute_log_unconstrained(*context, note, recipient, sender) };\n        context.emit_raw_note_log(encrypted_log, note_hash_counter);\n    }\n}\n\nmod test {\n    use crate::test::{helpers::test_environment::TestEnvironment, mocks::mock_note::MockNote};\n    use dep::protocol_types::address::AztecAddress;\n    use std::test::OracleMock;\n\n    #[test]\n    unconstrained fn test_encrypted_log_matches_typescript() {\n        let mut env = TestEnvironment::new();\n        // Advance 1 block so we can read historic state from private\n        env.advance_block_by(1);\n        let mut context = env.private();\n\n        // I'm not sure how to initialise an `env` or `context` with a consistent contract address for every run of this test; the value kept changing each time. So I'm going to overwrite it now:\n        context.inputs.call_context.contract_address = AztecAddress::from_field(\n            0x10f48cd9eff7ae5b209c557c70de2e657ee79166868676b787e9417e19260e04,\n        ); // This is an address copied to match the typescript one.\n\n        let storage_slot = 42;\n        let note = MockNote::new(1234)\n            .contract_address(context.this_address())\n            .storage_slot(storage_slot)\n            .build();\n        let contract_address = context.this_address();\n\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 = super::compute_note_plaintext_for_this_strategy(note);\n\n        let eph_sk = 0x1358d15019d4639393d62b97e1588c095957ce74a1c32d6ec7d62fe6705d9538;\n        let _ = OracleMock::mock(\"getRandomField\").returns(eph_sk).times(1);\n\n        let randomness = 0x0101010101010101010101010101010101010101010101010101010101010101;\n        let _ = OracleMock::mock(\"getRandomField\").returns(randomness).times(1000000);\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 = super::compute_log(context, note, recipient, sender);\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            0x0d460c0e434d846ec1ea286e4090eb56376ff27bddc1aacae1d856549f701fa7,\n            0x000194e6d7872db8f61e8e59f23580f4db45d13677f873ec473a409cf61fd04d,\n            0x00334e5fb6083721f3eb4eef500876af3c9acfab0a1cb1804b930606fdb0b283,\n            0x00af91db798fa320746831a59b74362dfd0cf9e7c239f6aad11a4b47d0d870ee,\n            0x00d25a054613a83be7be8512f2c09664bc4f7ab60a127b06584f476918581b8a,\n            0x003840d100d8c1d78d4b68b787ed353ebfb8cd2987503d3b472f614f25799a18,\n            0x003f38322629d401010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n            0x0101010101010101010101010101010101010101010101010101010101010101,\n        ];\n\n        assert_eq(payload, private_log_payload_from_typescript);\n    }\n}\n"
     },
-    "95": {
+    "94": {
       "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_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"
     }