@aztec/protocol-contracts 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/artifacts/ContractInstanceRegistry.json

@@ -14,247 +14,179 @@
       "path": "std/aes128.nr",
       "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n"
     },
-    "148": {
+    "14": {
       "function_locations": [
         {
-          "name": "<impl Empty for AztecAddress>::empty",
-          "start": 842
-        },
-        {
-          "name": "<impl ToField for AztecAddress>::to_field",
-          "start": 942
-        },
-        {
-          "name": "<impl FromField for AztecAddress>::from_field",
-          "start": 1054
-        },
-        {
-          "name": "AztecAddress::zero",
-          "start": 1149
-        },
-        {
-          "name": "AztecAddress::is_valid",
-          "start": 1479
-        },
-        {
-          "name": "AztecAddress::to_address_point",
-          "start": 1854
-        },
-        {
-          "name": "AztecAddress::is_positive",
-          "start": 2507
-        },
-        {
-          "name": "AztecAddress::get_y",
-          "start": 3363
-        },
-        {
-          "name": "AztecAddress::compute",
-          "start": 3749
-        },
-        {
-          "name": "AztecAddress::compute_from_class_id",
-          "start": 7971
-        },
-        {
-          "name": "AztecAddress::is_zero",
-          "start": 8243
-        },
-        {
-          "name": "AztecAddress::assert_is_zero",
-          "start": 8308
-        },
-        {
-          "name": "check_max_field_value",
-          "start": 8392
-        },
-        {
-          "name": "check_is_positive",
-          "start": 8503
-        },
-        {
-          "name": "check_embedded_curve_point_add",
-          "start": 9024
-        },
-        {
-          "name": "check_embedded_curve_point_add_2",
-          "start": 9441
-        },
-        {
-          "name": "compute_address_from_partial_and_pub_keys",
-          "start": 9670
-        },
-        {
-          "name": "compute_preaddress_from_partial_and_pub_keys",
-          "start": 11501
-        },
-        {
-          "name": "from_field_to_field",
-          "start": 11850
-        },
-        {
-          "name": "serde",
-          "start": 11987
-        },
-        {
-          "name": "to_address_point_valid",
-          "start": 12393
+          "name": "EmbeddedCurvePoint::new",
+          "start": 510
         },
-        {
-          "name": "to_address_point_invalid",
-          "start": 13057
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V1, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, ToPoint, TpkM},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::Point;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\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 AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: Point { x: self.inner, y: final_y, is_infinite: false } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                     /   /    \\    \\        .\n        //                         /                        \\              Npk_m Ivpk_m Ovpk_m Tpk_m   .\n        //          contract_class_id                         \\                     |...................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment       salted_initialization_hash\n        //                 |                                         /     /        \\\n        //     private_function_tree_root              deployer_address  salt   initialization_hash\n        //             /       \\                                                /              \\\n        //          ...          ...                              constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\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            DOM_SEP__CONTRACT_ADDRESS_V1,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        // TODO(F-553): Drop the `.to_embedded()` / `.into()` round-trip once the custom `Point` wrapper is removed and\n        // we use `EmbeddedCurvePoint` directly.\n        let address_point: Point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address))\n            .add(public_keys.ivpk_m.to_point().to_embedded())\n            .into();\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 secret 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_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\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 check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve:\n    let p1 = Point { x: 1, y: 1, is_infinite: false };\n    let p2 = Point::generator();\n    let _ = p1 + p2;\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add_2() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = Point::generator();\n    let p2 = Point { x: 1, y: 1, is_infinite: false };\n    let _ = p1 + p2;\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        0x2f66081d4bb077fbe8e8abe96a3516a713a3d7e34360b4e985da0da95092b37d;\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], DOM_SEP__CONTRACT_ADDRESS_V1);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x286c7755f2924b1e53b00bcaf1adaffe7287bd74bba7a02f4ab867e3892d28da;\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    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
-    },
-    "15": {
-      "function_locations": [
         {
           "name": "EmbeddedCurvePoint::double",
-          "start": 559
+          "start": 705
         },
         {
           "name": "EmbeddedCurvePoint::point_at_infinity",
-          "start": 731
+          "start": 877
         },
         {
           "name": "EmbeddedCurvePoint::generator",
-          "start": 872
+          "start": 1018
         },
         {
           "name": "EmbeddedCurvePoint::is_infinite",
-          "start": 1183
+          "start": 1329
         },
         {
           "name": "<impl Add for EmbeddedCurvePoint>::add",
-          "start": 1430
+          "start": 1576
         },
         {
           "name": "<impl Sub for EmbeddedCurvePoint>::sub",
-          "start": 1647
+          "start": 1793
         },
         {
           "name": "<impl Neg for EmbeddedCurvePoint>::neg",
-          "start": 1905
+          "start": 2051
         },
         {
           "name": "<impl Eq for EmbeddedCurvePoint>::eq",
-          "start": 2099
+          "start": 2245
         },
         {
           "name": "<impl Hash for EmbeddedCurvePoint>::hash",
-          "start": 2269
+          "start": 2415
         },
         {
           "name": "EmbeddedCurveScalar::new",
-          "start": 2823
+          "start": 2969
         },
         {
           "name": "EmbeddedCurveScalar::from_field",
-          "start": 3008
-        },
-        {
-          "name": "EmbeddedCurveScalar::from_bytes",
-          "start": 3354
+          "start": 3154
         },
         {
           "name": "<impl Eq for EmbeddedCurveScalar>::eq",
-          "start": 3800
+          "start": 3342
         },
         {
           "name": "<impl Hash for EmbeddedCurveScalar>::hash",
-          "start": 3983
+          "start": 3525
         },
         {
           "name": "multi_scalar_mul",
-          "start": 4659
+          "start": 4201
         },
         {
           "name": "fixed_base_scalar_mul",
-          "start": 4874
+          "start": 4416
         },
         {
           "name": "multi_scalar_mul_array_return",
-          "start": 5157
+          "start": 4699
         },
         {
           "name": "embedded_curve_add",
-          "start": 5612
+          "start": 5154
         },
         {
           "name": "embedded_curve_add_array_return",
-          "start": 5897
+          "start": 5439
         }
       ],
       "path": "std/embedded_curve_ops.nr",
-      "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0 }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n        }\n    }\n\n    /// True if this point is the point at infinity\n    pub fn is_infinite(self) -> bool {\n        (self.x == 0) & (self.y == 0)\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.x == b.x) & (self.y == b.y)\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.x.hash(state);\n        self.y.hash(state);\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    /// Create a new scalar using the provided (lo, hi) pair\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    /// Create a scalar from the given bn254 field value\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n\n    /// Take the first (after the specified offset) 16 bytes of the input as the lo value, and the next 16 bytes as the hi value\n    #[field(bn254)]\n    pub(crate) fn from_bytes(bytes: [u8; 64], offset: u32) -> EmbeddedCurveScalar {\n        let mut v = 1;\n        let mut lo = 0 as Field;\n        let mut hi = 0 as Field;\n        for i in 0..16 {\n            lo = lo + (bytes[offset + 31 - i] as Field) * v;\n            hi = hi + (bytes[offset + 15 - i] as Field) * v;\n            v = v * 256;\n        }\n        let sig_s = crate::embedded_curve_ops::EmbeddedCurveScalar { lo, hi };\n        sig_s\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n/// Computes a multi scalar multiplication over the embedded curve.\n/// For bn254, We have Grumpkin.\n///\n/// The embedded curve being used is decided by the\n/// underlying proof system.\n///\n/// IMPORTANT: Prefer `multi_scalar_mul()` over repeated `embedded_curve_add()`\n/// for adding multiple points. This is significantly more efficient.\n/// For adding exactly 2 points, use `embedded_curve_add()` directly.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// Elliptic curve addition\n/// IMPORTANT: this function is expected to perform a full addition in order to handle all corner cases:\n/// - points on the curve\n/// - point doubling\n/// - point at infinity\n/// As a result, you may not get optimal performance, depending on the assumptions of your inputs.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n"
+      "source": "use crate::cmp::Eq;\nuse crate::hash::Hash;\nuse crate::ops::arith::{Add, Neg, Sub};\n\n/// A point on the embedded elliptic curve\n/// By definition, the base field of the embedded curve is the scalar field of the proof system curve, i.e the Noir Field.\n/// x and y denotes the Weierstrass coordinates of the point.\npub struct EmbeddedCurvePoint {\n    pub x: Field,\n    pub y: Field,\n}\n\nimpl EmbeddedCurvePoint {\n    /// Create a new point using the provided (x, y) pair\n    pub fn new(x: Field, y: Field) -> Self {\n        EmbeddedCurvePoint { x, y }\n    }\n\n    /// Elliptic curve point doubling operation\n    /// returns the doubled point of a point P, i.e P+P\n    pub fn double(self) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, self)\n    }\n\n    /// Returns the null element of the curve; 'the point at infinity'\n    pub fn point_at_infinity() -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: 0, y: 0 }\n    }\n\n    /// Returns the curve's generator point.\n    pub fn generator() -> EmbeddedCurvePoint {\n        // Generator point for the grumpkin curve (y^2 = x^3 - 17)\n        EmbeddedCurvePoint {\n            x: 1,\n            y: 17631683881184975370165255887551781615748388533673675138860, // sqrt(-16)\n        }\n    }\n\n    /// True if this point is the point at infinity\n    pub fn is_infinite(self) -> bool {\n        (self.x == 0) & (self.y == 0)\n    }\n}\n\nimpl Add for EmbeddedCurvePoint {\n    /// Adds two points P+Q, using the curve addition formula, and also handles point at infinity\n    fn add(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        embedded_curve_add(self, other)\n    }\n}\n\nimpl Sub for EmbeddedCurvePoint {\n    /// Points subtraction operation, using addition and negation\n    fn sub(self, other: EmbeddedCurvePoint) -> EmbeddedCurvePoint {\n        self + other.neg()\n    }\n}\n\nimpl Neg for EmbeddedCurvePoint {\n    /// Negates a point P, i.e returns -P, by negating the y coordinate.\n    /// If the point is at infinity, then the result is also at infinity.\n    fn neg(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: -self.y }\n    }\n}\n\nimpl Eq for EmbeddedCurvePoint {\n    /// Checks whether two points are equal\n    fn eq(self: Self, b: EmbeddedCurvePoint) -> bool {\n        (self.x == b.x) & (self.y == b.y)\n    }\n}\n\nimpl Hash for EmbeddedCurvePoint {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.x.hash(state);\n        self.y.hash(state);\n    }\n}\n\n/// Scalar for the embedded curve represented as low and high limbs\n/// By definition, the scalar field of the embedded curve is base field of the proving system curve.\n/// It may not fit into a Field element, so it is represented with two Field elements; its low and high limbs.\npub struct EmbeddedCurveScalar {\n    pub lo: Field,\n    pub hi: Field,\n}\n\nimpl EmbeddedCurveScalar {\n    /// Create a new scalar using the provided (lo, hi) pair\n    pub fn new(lo: Field, hi: Field) -> Self {\n        EmbeddedCurveScalar { lo, hi }\n    }\n\n    /// Create a scalar from the given bn254 field value\n    #[field(bn254)]\n    pub fn from_field(scalar: Field) -> EmbeddedCurveScalar {\n        let (a, b) = crate::field::bn254::decompose(scalar);\n        EmbeddedCurveScalar { lo: a, hi: b }\n    }\n}\n\nimpl Eq for EmbeddedCurveScalar {\n    fn eq(self, other: Self) -> bool {\n        (other.hi == self.hi) & (other.lo == self.lo)\n    }\n}\n\nimpl Hash for EmbeddedCurveScalar {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: crate::hash::Hasher,\n    {\n        self.hi.hash(state);\n        self.lo.hash(state);\n    }\n}\n\n/// Computes a multi scalar multiplication over the embedded curve.\n/// For bn254, We have Grumpkin.\n///\n/// The embedded curve being used is decided by the\n/// underlying proof system.\n///\n/// IMPORTANT: Prefer `multi_scalar_mul()` over repeated `embedded_curve_add()`\n/// for adding multiple points. This is significantly more efficient.\n/// For adding exactly 2 points, use `embedded_curve_add()` directly.\n// docs:start:multi_scalar_mul\npub fn multi_scalar_mul<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n) -> EmbeddedCurvePoint\n// docs:end:multi_scalar_mul\n{\n    multi_scalar_mul_array_return(points, scalars, true)[0]\n}\n\n// docs:start:fixed_base_scalar_mul\npub fn fixed_base_scalar_mul(scalar: EmbeddedCurveScalar) -> EmbeddedCurvePoint\n// docs:end:fixed_base_scalar_mul\n{\n    multi_scalar_mul([EmbeddedCurvePoint::generator()], [scalar])\n}\n\n#[foreign(multi_scalar_mul)]\npub(crate) fn multi_scalar_mul_array_return<let N: u32>(\n    points: [EmbeddedCurvePoint; N],\n    scalars: [EmbeddedCurveScalar; N],\n    predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n\n/// Elliptic curve addition\n/// IMPORTANT: this function is expected to perform a full addition in order to handle all corner cases:\n/// - points on the curve\n/// - point doubling\n/// - point at infinity\n/// As a result, you may not get optimal performance, depending on the assumptions of your inputs.\n// docs:start:embedded_curve_add\npub fn embedded_curve_add(\n    point1: EmbeddedCurvePoint,\n    point2: EmbeddedCurvePoint,\n) -> EmbeddedCurvePoint {\n    // docs:end:embedded_curve_add\n    embedded_curve_add_array_return(point1, point2, true)[0]\n}\n\n#[foreign(embedded_curve_add)]\nfn embedded_curve_add_array_return(\n    _point1: EmbeddedCurvePoint,\n    _point2: EmbeddedCurvePoint,\n    _predicate: bool,\n) -> [EmbeddedCurvePoint; 1] {}\n"
     },
-    "151": {
+    "148": {
       "function_locations": [
         {
-          "name": "<impl ToField for PartialAddress>::to_field",
-          "start": 489
+          "name": "<impl Empty for AztecAddress>::empty",
+          "start": 853
         },
         {
-          "name": "<impl Empty for PartialAddress>::empty",
-          "start": 574
+          "name": "<impl ToField for AztecAddress>::to_field",
+          "start": 953
         },
         {
-          "name": "PartialAddress::from_field",
-          "start": 677
+          "name": "<impl FromField for AztecAddress>::from_field",
+          "start": 1065
         },
         {
-          "name": "PartialAddress::compute",
-          "start": 883
+          "name": "AztecAddress::zero",
+          "start": 1160
         },
         {
-          "name": "PartialAddress::compute_from_salted_initialization_hash",
-          "start": 1254
+          "name": "AztecAddress::is_valid",
+          "start": 1490
         },
         {
-          "name": "PartialAddress::to_field",
-          "start": 1496
+          "name": "AztecAddress::to_address_point",
+          "start": 1865
         },
         {
-          "name": "PartialAddress::is_zero",
-          "start": 1557
+          "name": "AztecAddress::is_positive",
+          "start": 2511
         },
         {
-          "name": "PartialAddress::assert_is_zero",
-          "start": 1627
+          "name": "AztecAddress::get_y",
+          "start": 3367
         },
         {
-          "name": "test::serialization_of_partial_address",
-          "start": 1835
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/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::DOM_SEP__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Serialize, ToField},\n};\nuse std::meta::derive;\n\n// Partial address\n#[derive(Deserialize, Eq, Serialize)]\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 Empty for PartialAddress {\n    fn empty() -> Self {\n        Self { inner: 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            DOM_SEP__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\nmod test {\n    use crate::{address::partial_address::PartialAddress, traits::{Deserialize, Serialize}};\n\n    #[test]\n    fn serialization_of_partial_address() {\n        let item = PartialAddress::from_field(1);\n        let serialized: [Field; 1] = item.serialize();\n        let deserialized = PartialAddress::deserialize(serialized);\n        assert_eq(item, deserialized);\n    }\n}\n"
-    },
-    "153": {
-      "function_locations": [
+          "name": "AztecAddress::compute",
+          "start": 3753
+        },
         {
-          "name": "<impl ToField for SaltedInitializationHash>::to_field",
-          "start": 383
+          "name": "AztecAddress::compute_from_class_id",
+          "start": 7944
         },
         {
-          "name": "SaltedInitializationHash::from_field",
-          "start": 489
+          "name": "AztecAddress::is_zero",
+          "start": 8216
         },
         {
-          "name": "SaltedInitializationHash::compute",
-          "start": 620
+          "name": "AztecAddress::assert_is_zero",
+          "start": 8281
         },
         {
-          "name": "SaltedInitializationHash::assert_is_zero",
-          "start": 848
+          "name": "check_max_field_value",
+          "start": 8365
+        },
+        {
+          "name": "check_is_positive",
+          "start": 8476
+        },
+        {
+          "name": "check_embedded_curve_point_add",
+          "start": 8997
+        },
+        {
+          "name": "compute_address_from_partial_and_pub_keys",
+          "start": 9262
+        },
+        {
+          "name": "compute_preaddress_from_partial_and_pub_keys",
+          "start": 11366
+        },
+        {
+          "name": "from_field_to_field",
+          "start": 11715
+        },
+        {
+          "name": "serde",
+          "start": 11852
+        },
+        {
+          "name": "to_address_point_valid",
+          "start": 12258
+        },
+        {
+          "name": "to_address_point_invalid",
+          "start": 12922
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
-      "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::DOM_SEP__PARTIAL_ADDRESS,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\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            DOM_SEP__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+      "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V2, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\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 AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\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            DOM_SEP__CONTRACT_ADDRESS_V2,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\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 secret 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_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\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 check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x303ffc8bd456d132463b1fc3a633aeb718a7883c268f3956c05e6fe09b5a5424;\n    assert_eq(address, 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], DOM_SEP__CONTRACT_ADDRESS_V2);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x0fa1c698858df1a99170cd39d5f4bfad6d0d60f1f8afa3dc92281ee60b36f3bb;\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    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
     },
-    "16": {
+    "15": {
       "function_locations": [
         {
           "name": "compute_decomposition",
@@ -324,7 +256,71 @@
       "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\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 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 = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\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, lt, 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_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_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        assert_gt(0 - 1, 0);\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    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
     },
-    "17": {
+    "151": {
+      "function_locations": [
+        {
+          "name": "<impl ToField for PartialAddress>::to_field",
+          "start": 489
+        },
+        {
+          "name": "<impl Empty for PartialAddress>::empty",
+          "start": 574
+        },
+        {
+          "name": "PartialAddress::from_field",
+          "start": 677
+        },
+        {
+          "name": "PartialAddress::compute",
+          "start": 915
+        },
+        {
+          "name": "PartialAddress::compute_from_salted_initialization_hash",
+          "start": 1303
+        },
+        {
+          "name": "PartialAddress::to_field",
+          "start": 1545
+        },
+        {
+          "name": "PartialAddress::is_zero",
+          "start": 1606
+        },
+        {
+          "name": "PartialAddress::assert_is_zero",
+          "start": 1676
+        },
+        {
+          "name": "test::serialization_of_partial_address",
+          "start": 1884
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/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::DOM_SEP__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Serialize, ToField},\n};\nuse std::meta::derive;\n\n// Partial address\n#[derive(Deserialize, Eq, Serialize)]\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 Empty for PartialAddress {\n    fn empty() -> Self {\n        Self { inner: 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        immutables_hash: Field,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer, immutables_hash),\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            DOM_SEP__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\nmod test {\n    use crate::{address::partial_address::PartialAddress, traits::{Deserialize, Serialize}};\n\n    #[test]\n    fn serialization_of_partial_address() {\n        let item = PartialAddress::from_field(1);\n        let serialized: [Field; 1] = item.serialize();\n        let deserialized = PartialAddress::deserialize(serialized);\n        assert_eq(item, deserialized);\n    }\n}\n"
+    },
+    "153": {
+      "function_locations": [
+        {
+          "name": "<impl ToField for SaltedInitializationHash>::to_field",
+          "start": 394
+        },
+        {
+          "name": "SaltedInitializationHash::from_field",
+          "start": 500
+        },
+        {
+          "name": "SaltedInitializationHash::compute",
+          "start": 694
+        },
+        {
+          "name": "SaltedInitializationHash::assert_is_zero",
+          "start": 950
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
+      "source": "use crate::{\n    address::aztec_address::AztecAddress, constants::DOM_SEP__SALTED_INITIALIZATION_HASH,\n    hash::poseidon2_hash_with_separator, traits::ToField,\n};\n\n// Salted initialization hash. Used in the computation of a partial address.\n#[derive(Eq)]\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(\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n        immutables_hash: Field,\n    ) -> Self {\n        SaltedInitializationHash::from_field(poseidon2_hash_with_separator(\n            [salt, initialization_hash, deployer.to_field(), immutables_hash],\n            DOM_SEP__SALTED_INITIALIZATION_HASH,\n        ))\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n"
+    },
+    "16": {
       "function_locations": [
         {
           "name": "Field::assert_max_bit_size",
@@ -537,69 +533,227 @@
         {
           "name": "tests::test_to_from_le_bits_bn254_edge_cases",
           "start": 26971
+        },
+        {
+          "name": "tests::max_bit_size_too_large",
+          "start": 28903
         }
       ],
       "path": "std/field/mod.nr",
-      "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n}\n"
+      "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn max_bit_size_too_large() {\n        let x: Field = 0x010000;\n        x.assert_max_bit_size::<16>();\n    }\n\n}\n"
     },
-    "171": {
+    "17": {
       "function_locations": [
         {
-          "name": "DelayedPublicMutableValues<T, INITIAL_DELAY>::new",
-          "start": 1463
+          "name": "sha256_compression",
+          "start": 572
         },
         {
-          "name": "unpack_value_change",
-          "start": 1817
+          "name": "keccakf1600",
+          "start": 707
         },
         {
-          "name": "unpack_delay_change",
-          "start": 2703
+          "name": "keccak::keccakf1600",
+          "start": 882
         },
         {
-          "name": "<impl Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>>::pack",
-          "start": 4565
+          "name": "blake2s",
+          "start": 1044
         },
         {
-          "name": "<impl Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>>::unpack",
-          "start": 5966
+          "name": "blake3",
+          "start": 1142
         },
         {
-          "name": "<impl Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>>::hash",
-          "start": 6265
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
-      "source": "use crate::{\n    delayed_public_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    hash::poseidon2_hash,\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        DelayedPublicMutableValues { svc, sdc }\n    }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n    T: Packable<N = M>,\n{\n    let svc_pre_packed = arrays::subarray(packed, 1);\n    let svc_post_packed = arrays::subarray(packed, M + 1);\n\n    // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n    // occupies the first 32 bits of the field.\n    let timestamp_of_change = (packed[0] as u32) as u64;\n    ScheduledValueChange::new(\n        T::unpack(svc_pre_packed),\n        T::unpack(svc_post_packed),\n        timestamp_of_change,\n    )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n    packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n    // This function expects to be called with just the first field of the packed representation, which contains sdc\n    // and svc timestamp_of_change. We'll discard the svc component.\n    let svc_timestamp_of_change = packed as u32;\n\n    let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_timestamp_of_change = tmp as u32;\n\n    tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_post_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n    let sdc_post_inner = tmp as u32;\n\n    tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n    let sdc_pre_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n    let sdc_pre_inner = tmp as u32;\n\n    // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n    // the values as u32 is a tech debt that is not worth tackling.\n    ScheduledDelayChange {\n        pre: if sdc_pre_is_some {\n            Option::some(sdc_pre_inner as u64)\n        } else {\n            Option::none()\n        },\n        post: if sdc_post_is_some {\n            Option::some(sdc_post_inner as u64)\n        } else {\n            Option::none()\n        },\n        timestamp_of_change: sdc_timestamp_of_change as u64,\n    }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    let N: u32 = 2 * <T as Packable>::N + 1;\n\n    fn pack(self) -> [Field; Self::N] {\n        let mut result = [0; Self::N];\n\n        // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n        // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n        result[0] = self.svc.timestamp_of_change as Field\n            + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..<T as Packable>::N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let svc = unpack_value_change::<T, _>(fields);\n        let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
-    },
-    "174": {
-      "function_locations": [
+          "name": "__blake3",
+          "start": 1629
+        },
         {
-          "name": "ScheduledDelayChange<INITIAL_DELAY>::new",
-          "start": 1413
+          "name": "pedersen_commitment",
+          "start": 1747
         },
         {
-          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_current",
-          "start": 1804
+          "name": "pedersen_commitment_with_separator",
+          "start": 1976
         },
         {
-          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_scheduled",
-          "start": 2560
+          "name": "pedersen_hash",
+          "start": 2380
         },
         {
-          "name": "ScheduledDelayChange<INITIAL_DELAY>::schedule_change",
-          "start": 3323
+          "name": "pedersen_hash_with_separator",
+          "start": 2537
         },
         {
-          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_effective_minimum_delay_at",
-          "start": 8464
+          "name": "derive_generators",
+          "start": 3531
         },
         {
-          "name": "<impl Eq for ScheduledDelayChange<INITIAL_DELAY>>::eq",
-          "start": 23536
+          "name": "__derive_generators",
+          "start": 3890
         },
         {
-          "name": "<impl Empty for ScheduledDelayChange<INITIAL_DELAY>>::empty",
+          "name": "poseidon2_permutation",
+          "start": 3968
+        },
+        {
+          "name": "poseidon2_permutation_internal",
+          "start": 4324
+        },
+        {
+          "name": "poseidon2_config_state_size",
+          "start": 4417
+        },
+        {
+          "name": "derive_hash",
+          "start": 4728
+        },
+        {
+          "name": "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher",
+          "start": 5953
+        },
+        {
+          "name": "<impl Default for BuildHasherDefault<H>>::default",
+          "start": 6085
+        },
+        {
+          "name": "<impl Hash for Field>::hash",
+          "start": 6217
+        },
+        {
+          "name": "<impl Hash for u8>::hash",
+          "start": 6347
+        },
+        {
+          "name": "<impl Hash for u16>::hash",
+          "start": 6487
+        },
+        {
+          "name": "<impl Hash for u32>::hash",
+          "start": 6627
+        },
+        {
+          "name": "<impl Hash for u64>::hash",
+          "start": 6767
+        },
+        {
+          "name": "<impl Hash for u128>::hash",
+          "start": 6908
+        },
+        {
+          "name": "<impl Hash for i8>::hash",
+          "start": 7047
+        },
+        {
+          "name": "<impl Hash for i16>::hash",
+          "start": 7193
+        },
+        {
+          "name": "<impl Hash for i32>::hash",
+          "start": 7340
+        },
+        {
+          "name": "<impl Hash for i64>::hash",
+          "start": 7487
+        },
+        {
+          "name": "<impl Hash for bool>::hash",
+          "start": 7635
+        },
+        {
+          "name": "<impl Hash for ()>::hash",
+          "start": 7782
+        },
+        {
+          "name": "<impl Hash for [T; N]>::hash",
+          "start": 7914
+        },
+        {
+          "name": "<impl Hash for [T]>::hash",
+          "start": 8103
+        },
+        {
+          "name": "<impl Hash for (A, B)>::hash",
+          "start": 8343
+        },
+        {
+          "name": "<impl Hash for (A, B, C)>::hash",
+          "start": 8559
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D)>::hash",
+          "start": 8822
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E)>::hash",
+          "start": 9132
+        },
+        {
+          "name": "assert_pedersen",
+          "start": 9528
+        }
+      ],
+      "path": "std/hash/mod.nr",
+      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\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::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\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// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\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        points[i] = EmbeddedCurveScalar::from_field(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    crate::assert_constant(separator);\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] = EmbeddedCurveScalar::from_field(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, true)[0].x\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    crate::assert_constant(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\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\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: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::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    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\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 {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\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 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 u128 {\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 u8 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 u16 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 u32 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 u64 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<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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\n    );\n}\n"
+    },
+    "171": {
+      "function_locations": [
+        {
+          "name": "DelayedPublicMutableValues<T, INITIAL_DELAY>::new",
+          "start": 1463
+        },
+        {
+          "name": "unpack_value_change",
+          "start": 1817
+        },
+        {
+          "name": "unpack_delay_change",
+          "start": 2703
+        },
+        {
+          "name": "<impl Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>>::pack",
+          "start": 4565
+        },
+        {
+          "name": "<impl Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>>::unpack",
+          "start": 5966
+        },
+        {
+          "name": "<impl Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>>::hash",
+          "start": 6265
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
+      "source": "use crate::{\n    delayed_public_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    hash::poseidon2_hash,\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        DelayedPublicMutableValues { svc, sdc }\n    }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n    T: Packable<N = M>,\n{\n    let svc_pre_packed = arrays::subarray(packed, 1);\n    let svc_post_packed = arrays::subarray(packed, M + 1);\n\n    // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n    // occupies the first 32 bits of the field.\n    let timestamp_of_change = (packed[0] as u32) as u64;\n    ScheduledValueChange::new(\n        T::unpack(svc_pre_packed),\n        T::unpack(svc_post_packed),\n        timestamp_of_change,\n    )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n    packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n    // This function expects to be called with just the first field of the packed representation, which contains sdc\n    // and svc timestamp_of_change. We'll discard the svc component.\n    let svc_timestamp_of_change = packed as u32;\n\n    let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_timestamp_of_change = tmp as u32;\n\n    tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_post_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n    let sdc_post_inner = tmp as u32;\n\n    tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n    let sdc_pre_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n    let sdc_pre_inner = tmp as u32;\n\n    // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n    // the values as u32 is a tech debt that is not worth tackling.\n    ScheduledDelayChange {\n        pre: if sdc_pre_is_some {\n            Option::some(sdc_pre_inner as u64)\n        } else {\n            Option::none()\n        },\n        post: if sdc_post_is_some {\n            Option::some(sdc_post_inner as u64)\n        } else {\n            Option::none()\n        },\n        timestamp_of_change: sdc_timestamp_of_change as u64,\n    }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    let N: u32 = 2 * <T as Packable>::N + 1;\n\n    fn pack(self) -> [Field; Self::N] {\n        let mut result = [0; Self::N];\n\n        // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n        // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n        result[0] = self.svc.timestamp_of_change as Field\n            + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..<T as Packable>::N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let svc = unpack_value_change::<T, _>(fields);\n        let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
+    },
+    "174": {
+      "function_locations": [
+        {
+          "name": "ScheduledDelayChange<INITIAL_DELAY>::new",
+          "start": 1413
+        },
+        {
+          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_current",
+          "start": 1804
+        },
+        {
+          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_scheduled",
+          "start": 2560
+        },
+        {
+          "name": "ScheduledDelayChange<INITIAL_DELAY>::schedule_change",
+          "start": 3323
+        },
+        {
+          "name": "ScheduledDelayChange<INITIAL_DELAY>::get_effective_minimum_delay_at",
+          "start": 8464
+        },
+        {
+          "name": "<impl Eq for ScheduledDelayChange<INITIAL_DELAY>>::eq",
+          "start": 23536
+        },
+        {
+          "name": "<impl Empty for ScheduledDelayChange<INITIAL_DELAY>>::empty",
           "start": 23789
         }
       ],
@@ -766,160 +920,6 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\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\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 compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\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        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::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 = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> 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.get(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 subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\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 unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "18": {
-      "function_locations": [
-        {
-          "name": "sha256_compression",
-          "start": 572
-        },
-        {
-          "name": "keccakf1600",
-          "start": 707
-        },
-        {
-          "name": "keccak::keccakf1600",
-          "start": 882
-        },
-        {
-          "name": "blake2s",
-          "start": 1044
-        },
-        {
-          "name": "blake3",
-          "start": 1142
-        },
-        {
-          "name": "__blake3",
-          "start": 1629
-        },
-        {
-          "name": "pedersen_commitment",
-          "start": 1747
-        },
-        {
-          "name": "pedersen_commitment_with_separator",
-          "start": 1976
-        },
-        {
-          "name": "pedersen_hash",
-          "start": 2380
-        },
-        {
-          "name": "pedersen_hash_with_separator",
-          "start": 2537
-        },
-        {
-          "name": "derive_generators",
-          "start": 3531
-        },
-        {
-          "name": "__derive_generators",
-          "start": 3890
-        },
-        {
-          "name": "poseidon2_permutation",
-          "start": 3968
-        },
-        {
-          "name": "poseidon2_permutation_internal",
-          "start": 4324
-        },
-        {
-          "name": "poseidon2_config_state_size",
-          "start": 4417
-        },
-        {
-          "name": "derive_hash",
-          "start": 4728
-        },
-        {
-          "name": "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher",
-          "start": 5953
-        },
-        {
-          "name": "<impl Default for BuildHasherDefault<H>>::default",
-          "start": 6085
-        },
-        {
-          "name": "<impl Hash for Field>::hash",
-          "start": 6217
-        },
-        {
-          "name": "<impl Hash for u8>::hash",
-          "start": 6347
-        },
-        {
-          "name": "<impl Hash for u16>::hash",
-          "start": 6487
-        },
-        {
-          "name": "<impl Hash for u32>::hash",
-          "start": 6627
-        },
-        {
-          "name": "<impl Hash for u64>::hash",
-          "start": 6767
-        },
-        {
-          "name": "<impl Hash for u128>::hash",
-          "start": 6908
-        },
-        {
-          "name": "<impl Hash for i8>::hash",
-          "start": 7047
-        },
-        {
-          "name": "<impl Hash for i16>::hash",
-          "start": 7193
-        },
-        {
-          "name": "<impl Hash for i32>::hash",
-          "start": 7340
-        },
-        {
-          "name": "<impl Hash for i64>::hash",
-          "start": 7487
-        },
-        {
-          "name": "<impl Hash for bool>::hash",
-          "start": 7635
-        },
-        {
-          "name": "<impl Hash for ()>::hash",
-          "start": 7782
-        },
-        {
-          "name": "<impl Hash for [T; N]>::hash",
-          "start": 7914
-        },
-        {
-          "name": "<impl Hash for [T]>::hash",
-          "start": 8103
-        },
-        {
-          "name": "<impl Hash for (A, B)>::hash",
-          "start": 8343
-        },
-        {
-          "name": "<impl Hash for (A, B, C)>::hash",
-          "start": 8559
-        },
-        {
-          "name": "<impl Hash for (A, B, C, D)>::hash",
-          "start": 8822
-        },
-        {
-          "name": "<impl Hash for (A, B, C, D, E)>::hash",
-          "start": 9132
-        },
-        {
-          "name": "assert_pedersen",
-          "start": 9528
-        }
-      ],
-      "path": "std/hash/mod.nr",
-      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\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::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\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// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\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        points[i] = EmbeddedCurveScalar::from_field(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    crate::assert_constant(separator);\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] = EmbeddedCurveScalar::from_field(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, true)[0].x\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    crate::assert_constant(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\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\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: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::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    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\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 {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\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 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 u128 {\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 u8 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 u16 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 u32 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 u64 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<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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\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        },\n    );\n}\n"
-    },
     "181": {
       "function_locations": [
         {
@@ -963,212 +963,116 @@
           "start": 1288
         },
         {
-          "name": "info_log_format",
-          "start": 1414
-        },
-        {
-          "name": "verbose_log_format",
-          "start": 1543
-        },
-        {
-          "name": "debug_log_format",
-          "start": 1673
-        },
-        {
-          "name": "trace_log_format",
-          "start": 1801
-        },
-        {
-          "name": "log_format",
-          "start": 1934
-        },
-        {
-          "name": "log_oracle_wrapper",
-          "start": 2248
-        },
-        {
-          "name": "log_oracle",
-          "start": 2801
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
-      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, 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 { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_utl_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
-    },
-    "199": {
-      "function_locations": [
-        {
-          "name": "Point::generator",
-          "start": 918
-        },
-        {
-          "name": "Point::point_at_infinity",
-          "start": 1068
-        },
-        {
-          "name": "Point::double",
-          "start": 1157
-        },
-        {
-          "name": "Point::to_embedded",
-          "start": 1260
-        },
-        {
-          "name": "<impl From<EmbeddedCurvePoint> for Point>::from",
-          "start": 1408
-        },
-        {
-          "name": "<impl std::ops::Add for Point>::add",
-          "start": 1553
-        },
-        {
-          "name": "<impl std::ops::Sub for Point>::sub",
-          "start": 1693
-        },
-        {
-          "name": "<impl std::ops::Neg for Point>::neg",
-          "start": 1819
-        },
-        {
-          "name": "<impl Eq for Point>::eq",
-          "start": 1959
-        },
-        {
-          "name": "<impl Hash for Point>::hash",
-          "start": 2111
-        },
-        {
-          "name": "<impl Empty for Point>::empty",
-          "start": 2381
-        },
-        {
-          "name": "<impl Serialize for Point>::serialize",
-          "start": 2543
-        },
-        {
-          "name": "<impl Serialize for Point>::stream_serialize",
-          "start": 2670
-        },
-        {
-          "name": "<impl Deserialize for Point>::deserialize",
-          "start": 2904
-        },
-        {
-          "name": "<impl Deserialize for Point>::stream_deserialize",
-          "start": 3078
-        },
-        {
-          "name": "validate_on_curve",
-          "start": 3210
-        },
-        {
-          "name": "<impl Packable for Point>::pack",
-          "start": 3761
+          "name": "info_log_format",
+          "start": 1414
         },
         {
-          "name": "<impl Packable for Point>::unpack",
-          "start": 3843
+          "name": "verbose_log_format",
+          "start": 1543
         },
         {
-          "name": "tests::test_validate_on_curve_generator",
-          "start": 4012
+          "name": "debug_log_format",
+          "start": 1673
         },
         {
-          "name": "tests::test_validate_on_curve_infinity",
-          "start": 4224
+          "name": "trace_log_format",
+          "start": 1801
         },
         {
-          "name": "tests::test_validate_on_curve_invalid_point",
-          "start": 4506
+          "name": "log_format",
+          "start": 1934
         },
         {
-          "name": "tests::test_validate_on_curve_infinity_non_canonical_x",
-          "start": 4829
+          "name": "log_oracle_wrapper",
+          "start": 2248
         },
         {
-          "name": "tests::test_validate_on_curve_infinity_non_canonical_y",
-          "start": 5175
+          "name": "log_oracle",
+          "start": 2802
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
+      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, 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 { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_misc_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
+    },
+    "199": {
+      "function_locations": [
+        {
+          "name": "validate_on_curve",
+          "start": 167
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/point.nr",
-      "source": "use crate::{\n    hash::poseidon2_hash,\n    traits::{Deserialize, Empty, Hash, Packable, Serialize},\n    utils::{reader::Reader, writer::Writer},\n};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\n\npub global POINT_LENGTH: u32 = 3;\n\n// TODO(F-553): This custom `Point` struct is a temporary workaround. A newer version of Noir dropped the `is_infinite`\n// field from `EmbeddedCurvePoint` and changed its serialization from 3 fields to 2. To preserve backwards compatibility\n// of our onchain serialization format we re-introduced our own `Point` that wraps `EmbeddedCurvePoint` and keeps the\n// old 3-field layout. Once we're ready to take the breaking change (e.g. alongside the v5 oracle changes), delete this\n// struct, use `EmbeddedCurvePoint` directly and reduce `POINT_LENGTH` to 2.\npub struct Point {\n    pub x: Field,\n    pub y: Field,\n    pub is_infinite: bool,\n}\n\nimpl Point {\n    pub fn generator() -> Self {\n        let g = EmbeddedCurvePoint::generator();\n        Point { x: g.x, y: g.y, is_infinite: false }\n    }\n\n    pub fn point_at_infinity() -> Self {\n        Point { x: 0, y: 0, is_infinite: true }\n    }\n\n    pub fn double(self) -> Self {\n        self.to_embedded().double().into()\n    }\n\n    pub fn to_embedded(self) -> EmbeddedCurvePoint {\n        EmbeddedCurvePoint { x: self.x, y: self.y }\n    }\n}\n\nimpl From<EmbeddedCurvePoint> for Point {\n    fn from(p: EmbeddedCurvePoint) -> Self {\n        Point { x: p.x, y: p.y, is_infinite: p.is_infinite() }\n    }\n}\n\nimpl std::ops::Add for Point {\n    fn add(self, other: Point) -> Point {\n        (self.to_embedded() + other.to_embedded()).into()\n    }\n}\n\nimpl std::ops::Sub for Point {\n    fn sub(self, other: Point) -> Point {\n        (self.to_embedded() - other.to_embedded()).into()\n    }\n}\n\nimpl std::ops::Neg for Point {\n    fn neg(self) -> Point {\n        Point { x: self.x, y: -self.y, is_infinite: self.is_infinite }\n    }\n}\n\nimpl Eq for Point {\n    fn eq(self, other: Point) -> bool {\n        (self.x == other.x) & (self.y == other.y) & (self.is_infinite == other.is_infinite)\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 Serialize for Point {\n    let N: u32 = POINT_LENGTH;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.x, self.y, self.is_infinite as Field]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.x);\n        writer.write(self.y);\n        writer.write(self.is_infinite as Field);\n    }\n}\n\nimpl Deserialize for Point {\n    let N: u32 = POINT_LENGTH;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Point { x: fields[0], y: fields[1], is_infinite: fields[2] != 0 }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Point { x: reader.read(), y: reader.read(), is_infinite: reader.read_bool() }\n    }\n}\n\npub fn validate_on_curve(p: Point) {\n    // y^2 == x^3 - 17\n    let x = p.x;\n    let y = p.y;\n    if p.is_infinite {\n        // Assert the canonical representation of infinity\n        assert_eq(x, 0, \"Point at infinity should have canonical representation (0 0)\");\n        assert_eq(y, 0, \"Point at infinity should have canonical representation (0 0)\");\n    } else {\n        assert_eq(y * y, x * x * x - 17, \"Point not on curve\");\n    }\n}\n\n// TODO(#11356): use compact representation here.\nimpl Packable for Point {\n    let N: u32 = POINT_LENGTH;\n\n    fn pack(self) -> [Field; Self::N] {\n        self.serialize()\n    }\n\n    fn unpack(packed: [Field; Self::N]) -> Self {\n        Self::deserialize(packed)\n    }\n}\n\nmod tests {\n    use super::{Point, validate_on_curve};\n\n    #[test]\n    unconstrained fn test_validate_on_curve_generator() {\n        // The generator point should be on the curve\n        let generator = Point::generator();\n        validate_on_curve(generator);\n    }\n\n    #[test]\n    unconstrained fn test_validate_on_curve_infinity() {\n        // Canonical infinite point (x=0, y=0) should pass\n        let infinity = Point { x: 0, y: 0, is_infinite: true };\n        validate_on_curve(infinity);\n    }\n\n    #[test(should_fail_with = \"Point not on curve\")]\n    unconstrained fn test_validate_on_curve_invalid_point() {\n        // A point not on the curve should fail\n        let invalid = Point { x: 1, y: 1, is_infinite: false };\n        validate_on_curve(invalid);\n    }\n\n    #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n    unconstrained fn test_validate_on_curve_infinity_non_canonical_x() {\n        // Infinite point with non-zero x should fail\n        let invalid_infinity = Point { x: 1, y: 0, is_infinite: true };\n        validate_on_curve(invalid_infinity);\n    }\n\n    #[test(should_fail_with = \"Point at infinity should have canonical representation (0 0)\")]\n    unconstrained fn test_validate_on_curve_infinity_non_canonical_y() {\n        // Infinite point with non-zero y should fail\n        let invalid_infinity = Point { x: 0, y: 1, is_infinite: true };\n        validate_on_curve(invalid_infinity);\n    }\n}\n"
+      "source": "pub use std::embedded_curve_ops::EmbeddedCurvePoint;\n\n/// Validates that the given point exists on the Grumpkin curve.\npub fn validate_on_curve(p: EmbeddedCurvePoint) {\n    // y^2 == x^3 - 17\n    let x = p.x;\n    let y = p.y;\n    // p.is_infinite() <==> x == y == 0, considered on the curve:\n    if !p.is_infinite() {\n        assert_eq(y * y, x * x * x - 17, \"Point not on curve\");\n    }\n}\n"
     },
     "207": {
       "function_locations": [
         {
-          "name": "<impl ToPoint for NpkM>::to_point",
-          "start": 646
-        },
-        {
-          "name": "<impl Hash for NpkM>::hash",
-          "start": 816
+          "name": "hash_public_key",
+          "start": 772
         },
         {
           "name": "<impl ToPoint for IvpkM>::to_point",
-          "start": 991
-        },
-        {
-          "name": "<impl Hash for OvpkM>::hash",
-          "start": 1152
-        },
-        {
-          "name": "<impl ToPoint for OvpkM>::to_point",
-          "start": 1245
+          "start": 1029
         },
         {
-          "name": "<impl ToPoint for TpkM>::to_point",
-          "start": 1411
+          "name": "<impl Hash for IvpkM>::hash",
+          "start": 1108
         },
         {
           "name": "<impl Default for PublicKeys>::default",
-          "start": 1649
+          "start": 1840
         },
         {
           "name": "PublicKeys::hash",
-          "start": 2293
+          "start": 2297
         },
         {
           "name": "PublicKeys::validate_on_curve",
-          "start": 2492
+          "start": 2986
         },
         {
           "name": "PublicKeys::validate_non_infinity",
-          "start": 2722
+          "start": 3299
         },
         {
           "name": "<impl ToPoint for AddressPoint>::to_point",
-          "start": 3207
+          "start": 3543
+        },
+        {
+          "name": "test::default_hashes_match_default_points",
+          "start": 4552
         },
         {
           "name": "test::compute_public_keys_hash",
-          "start": 3517
+          "start": 5465
         },
         {
           "name": "test::test_validate_on_curve",
-          "start": 4231
+          "start": 6012
         },
         {
           "name": "test::test_validate_not_on_curve",
-          "start": 4690
+          "start": 6419
         },
         {
           "name": "test::test_validate_non_infinity",
-          "start": 5151
+          "start": 6778
         },
         {
           "name": "test::test_validate_infinity",
-          "start": 5621
+          "start": 7197
         },
         {
           "name": "test::compute_default_hash",
-          "start": 6015
+          "start": 7560
         },
         {
           "name": "test::serde",
-          "start": 6393
+          "start": 7868
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/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, DOM_SEP__PUBLIC_KEYS_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::validate_on_curve,\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse crate::point::Point;\nuse std::{default::Default, meta::derive};\n\npub trait ToPoint {\n    fn to_point(self) -> Point;\n}\n\n#[derive(Deserialize, Eq, Serialize)]\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\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\n#[derive(Deserialize, Eq, Serialize)]\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\n#[derive(Deserialize, Eq, Serialize)]\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\n#[derive(Deserialize, Eq, Serialize)]\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\n#[derive(Deserialize, Eq, Serialize)]\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\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 PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            self.serialize(),\n            DOM_SEP__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n\n    pub fn validate_on_curve(self) {\n        validate_on_curve(self.npk_m.inner);\n        validate_on_curve(self.ivpk_m.inner);\n        validate_on_curve(self.ovpk_m.inner);\n        validate_on_curve(self.tpk_m.inner);\n    }\n\n    pub fn validate_non_infinity(self) {\n        assert_eq(self.npk_m.inner.is_infinite, false, \"NpkM is the point at infinity\");\n        assert_eq(self.ivpk_m.inner.is_infinite, false, \"IvpkM is the point at infinity\");\n        assert_eq(self.ovpk_m.inner.is_infinite, false, \"OvpkM is the point at infinity\");\n        assert_eq(self.tpk_m.inner.is_infinite, false, \"TpkM is the point at infinity\");\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\nmod test {\n    use crate::point::Point;\n    use crate::{\n        point::POINT_LENGTH,\n        public_keys::{IvpkM, NpkM, OvpkM, PublicKeys, TpkM},\n        traits::{Deserialize, Serialize},\n    };\n    use std::ops::Neg;\n\n    #[test]\n    unconstrained 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\n        // The following value was generated by `public_keys.test.ts`.\n        let expected_public_keys_hash =\n            0x056998309f6c119e4d753e404f94fef859dddfa530a9379634ceb0854b29bf7a;\n\n        assert(actual.to_field() == expected_public_keys_hash);\n    }\n\n    #[test]\n    unconstrained fn test_validate_on_curve() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point::generator() },\n            ivpk_m: IvpkM { inner: Point::generator().double() },\n            ovpk_m: OvpkM { inner: Point::generator().neg() },\n            tpk_m: TpkM { inner: Point::generator() + Point::generator().double() },\n        };\n\n        keys.validate_on_curve();\n    }\n\n    #[test(should_fail_with = \"Point not on curve\")]\n    unconstrained fn test_validate_not_on_curve() {\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        keys.validate_on_curve();\n    }\n\n    #[test]\n    unconstrained fn test_validate_non_infinity() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point::generator() },\n            ivpk_m: IvpkM { inner: Point::generator().double() },\n            ovpk_m: OvpkM { inner: Point::generator().neg() },\n            tpk_m: TpkM { inner: Point::generator() + Point::generator().double() },\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test(should_fail_with = \"TpkM is the point at infinity\")]\n    unconstrained fn test_validate_infinity() {\n        let keys = PublicKeys {\n            npk_m: NpkM { inner: Point::generator() },\n            ivpk_m: IvpkM { inner: Point::generator().double() },\n            ovpk_m: OvpkM { inner: Point::generator().neg() },\n            tpk_m: TpkM { inner: Point::point_at_infinity() },\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test]\n    unconstrained fn compute_default_hash() {\n        let keys = PublicKeys::default();\n\n        let actual = keys.hash();\n\n        // The following value was generated by `public_keys.test.ts`.\n        let test_data_default_hash =\n            0x023547e676dba19784188825b901a0e70d8ad978300d21d6185a54281b734da0;\n\n        assert(actual.to_field() == test_data_default_hash);\n    }\n\n    #[test]\n    unconstrained fn serde() {\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        // We use the PUBLIC_KEYS_LENGTH constant to ensure that there is a match between the derived trait\n        let serialized: [Field; POINT_LENGTH * 4] = keys.serialize();\n        let deserialized = PublicKeys::deserialize(serialized);\n\n        assert_eq(keys, deserialized);\n    }\n}\n"
+      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_FBPK_M_HASH, DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_MSPK_M_HASH,\n        DEFAULT_NPK_M_HASH, DEFAULT_OVPK_M_HASH, DEFAULT_TPK_M_HASH, DOM_SEP__PUBLIC_KEYS_HASH,\n        DOM_SEP__SINGLE_PUBLIC_KEY_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::{EmbeddedCurvePoint, validate_on_curve},\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse std::{default::Default, meta::derive};\n\npub trait ToPoint {\n    fn to_point(self) -> EmbeddedCurvePoint;\n}\n\n/// Hashes a public key point under the canonical single-public-key domain separator.\n///\n/// Defined as `Poseidon2(DOM_SEP__SINGLE_PUBLIC_KEY_HASH, x, y)`.\npub fn hash_public_key(p: EmbeddedCurvePoint) -> Field {\n    poseidon2_hash_with_separator([p.x, p.y], DOM_SEP__SINGLE_PUBLIC_KEY_HASH as Field)\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct IvpkM {\n    pub inner: EmbeddedCurvePoint,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> EmbeddedCurvePoint {\n        self.inner\n    }\n}\n\nimpl Hash for IvpkM {\n    fn hash(self) -> Field {\n        hash_public_key(self.inner)\n    }\n}\n\n/// A non-owner's view of an account's master public keys.\n///\n/// `npk_m_hash`, `ovpk_m_hash`, `tpk_m_hash`, `mspk_m_hash`, and `fbpk_m_hash` are the\n/// [`hash_public_key`] digests of the underlying points. The points themselves are not exposed\n/// here - they are only known to the owner. `ivpk_m` remains a point because address derivation\n/// (encrypt-to-address) requires the raw point in-circuit.\n#[derive(Deserialize, Eq, Serialize)]\npub struct PublicKeys {\n    pub npk_m_hash: Field,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m_hash: Field,\n    pub tpk_m_hash: Field,\n    pub mspk_m_hash: Field,\n    pub fbpk_m_hash: Field,\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m_hash: DEFAULT_NPK_M_HASH,\n            ivpk_m: IvpkM {\n                inner: EmbeddedCurvePoint { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y },\n            },\n            ovpk_m_hash: DEFAULT_OVPK_M_HASH,\n            tpk_m_hash: DEFAULT_TPK_M_HASH,\n            mspk_m_hash: DEFAULT_MSPK_M_HASH,\n            fbpk_m_hash: DEFAULT_FBPK_M_HASH,\n        }\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            [\n                self.npk_m_hash,\n                self.ivpk_m.hash(),\n                self.ovpk_m_hash,\n                self.tpk_m_hash,\n                self.mspk_m_hash,\n                self.fbpk_m_hash,\n            ],\n            DOM_SEP__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n\n    /// Validates that the (only) point-form key, `ivpk_m`, lies on the Grumpkin curve.\n    ///\n    /// The other five keys are exposed only as hashes and are unverifiable on-circuit; the PXE\n    /// is responsible for ensuring they were derived from on-curve points before persistence.\n    pub fn validate_on_curve(self) {\n        validate_on_curve(self.ivpk_m.inner);\n    }\n\n    /// Validates that `ivpk_m` is not the point at infinity.\n    ///\n    /// As with [`Self::validate_on_curve`], the other five keys are now exposed only as hashes\n    /// and this property must be enforced PXE-side.\n    pub fn validate_non_infinity(self) {\n        assert_eq(self.ivpk_m.inner.is_infinite(), false, \"IvpkM is the point at infinity\");\n    }\n}\n\npub struct AddressPoint {\n    pub inner: EmbeddedCurvePoint,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> EmbeddedCurvePoint {\n        self.inner\n    }\n}\n\nmod test {\n    use crate::constants::{\n        DEFAULT_FBPK_M_HASH, DEFAULT_FBPK_M_X, DEFAULT_FBPK_M_Y, DEFAULT_MSPK_M_HASH,\n        DEFAULT_MSPK_M_X, DEFAULT_MSPK_M_Y, DEFAULT_NPK_M_HASH, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y,\n        DEFAULT_OVPK_M_HASH, DEFAULT_OVPK_M_X, DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_HASH,\n        DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y,\n    };\n    use crate::{\n        point::EmbeddedCurvePoint,\n        public_keys::{hash_public_key, IvpkM, PublicKeys},\n        traits::{Deserialize, Serialize},\n    };\n\n    global PUBLIC_KEYS_LENGTH: u32 = 7;\n\n    /// Catches drift between the precomputed `DEFAULT_*_M_HASH` constants and the\n    /// `DEFAULT_*_M_X/Y` curve points they're derived from. If anyone updates the X/Y\n    /// constants (or the hashing primitive) without also updating the *_HASH constants,\n    /// this test fails and `PublicKeys::default()` would silently produce a stale value.\n    #[test]\n    unconstrained fn default_hashes_match_default_points() {\n        let npk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y },\n        );\n        assert_eq(npk, DEFAULT_NPK_M_HASH);\n\n        let ovpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y },\n        );\n        assert_eq(ovpk, DEFAULT_OVPK_M_HASH);\n\n        let tpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y },\n        );\n        assert_eq(tpk, DEFAULT_TPK_M_HASH);\n\n        let mspk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_MSPK_M_X, y: DEFAULT_MSPK_M_Y },\n        );\n        assert_eq(mspk, DEFAULT_MSPK_M_HASH);\n\n        let fbpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_FBPK_M_X, y: DEFAULT_FBPK_M_Y },\n        );\n        assert_eq(fbpk, DEFAULT_FBPK_M_HASH);\n    }\n\n    #[test]\n    unconstrained fn compute_public_keys_hash() {\n        let keys = PublicKeys {\n            npk_m_hash: 11,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 22,\n            tpk_m_hash: 33,\n            mspk_m_hash: 44,\n            fbpk_m_hash: 55,\n        };\n\n        let actual = keys.hash().to_field();\n\n        let expected_public_keys_hash =\n            0x1e57c605207e2b607720b8e3023f69f5af25683277db5ff3b99f7948213c7878;\n\n        assert_eq(actual, expected_public_keys_hash);\n    }\n\n    #[test]\n    unconstrained fn test_validate_on_curve() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::generator().double() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_on_curve();\n    }\n\n    #[test(should_fail_with = \"Point not on curve\")]\n    unconstrained fn test_validate_not_on_curve() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_on_curve();\n    }\n\n    #[test]\n    unconstrained fn test_validate_non_infinity() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::generator().double() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test(should_fail_with = \"IvpkM is the point at infinity\")]\n    unconstrained fn test_validate_infinity() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::point_at_infinity() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test]\n    unconstrained fn compute_default_hash() {\n        let keys = PublicKeys::default();\n\n        let actual = keys.hash().to_field();\n\n        let test_data_default_hash =\n            0x13c13fbec22a396f700180c621fb8c67b830b431fed47d4dd71a20d828829eaa;\n\n        assert_eq(actual, test_data_default_hash);\n    }\n\n    #[test]\n    unconstrained fn serde() {\n        let keys = PublicKeys {\n            npk_m_hash: 11,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 22,\n            tpk_m_hash: 33,\n            mspk_m_hash: 44,\n            fbpk_m_hash: 55,\n        };\n\n        let serialized: [Field; PUBLIC_KEYS_LENGTH] = keys.serialize();\n        let deserialized = PublicKeys::deserialize(serialized);\n\n        assert_eq(keys, deserialized);\n    }\n}\n"
     },
     "212": {
       "function_locations": [
@@ -1184,128 +1088,6 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{\n    constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n    traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash_with_separator(\n        [storage_slot, key.to_field()],\n        DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n    )\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x2d225f361108379adc2da91378b9702675c5546b57e78bafc1e74ec7fec55967;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "220": {
-      "function_locations": [
-        {
-          "name": "<impl Packable for bool>::pack",
-          "start": 504
-        },
-        {
-          "name": "<impl Packable for bool>::unpack",
-          "start": 606
-        },
-        {
-          "name": "<impl Packable for u8>::pack",
-          "start": 767
-        },
-        {
-          "name": "<impl Packable for u8>::unpack",
-          "start": 869
-        },
-        {
-          "name": "<impl Packable for u16>::pack",
-          "start": 1021
-        },
-        {
-          "name": "<impl Packable for u16>::unpack",
-          "start": 1123
-        },
-        {
-          "name": "<impl Packable for u32>::pack",
-          "start": 1276
-        },
-        {
-          "name": "<impl Packable for u32>::unpack",
-          "start": 1378
-        },
-        {
-          "name": "<impl Packable for u64>::pack",
-          "start": 1531
-        },
-        {
-          "name": "<impl Packable for u64>::unpack",
-          "start": 1633
-        },
-        {
-          "name": "<impl Packable for u128>::pack",
-          "start": 1788
-        },
-        {
-          "name": "<impl Packable for u128>::unpack",
-          "start": 1890
-        },
-        {
-          "name": "<impl Packable for Field>::pack",
-          "start": 2048
-        },
-        {
-          "name": "<impl Packable for Field>::unpack",
-          "start": 2141
-        },
-        {
-          "name": "<impl Packable for i8>::pack",
-          "start": 2285
-        },
-        {
-          "name": "<impl Packable for i8>::unpack",
-          "start": 2393
-        },
-        {
-          "name": "<impl Packable for i16>::pack",
-          "start": 2551
-        },
-        {
-          "name": "<impl Packable for i16>::unpack",
-          "start": 2660
-        },
-        {
-          "name": "<impl Packable for i32>::pack",
-          "start": 2820
-        },
-        {
-          "name": "<impl Packable for i32>::unpack",
-          "start": 2929
-        },
-        {
-          "name": "<impl Packable for i64>::pack",
-          "start": 3089
-        },
-        {
-          "name": "<impl Packable for i64>::unpack",
-          "start": 3198
-        },
-        {
-          "name": "<impl Packable for [T; M]>::pack",
-          "start": 3407
-        },
-        {
-          "name": "<impl Packable for [T; M]>::unpack",
-          "start": 3769
-        },
-        {
-          "name": "test_u16_packing",
-          "start": 4014
-        },
-        {
-          "name": "test_i8_packing",
-          "start": 4110
-        },
-        {
-          "name": "test_i16_packing",
-          "start": 4206
-        },
-        {
-          "name": "test_i32_packing",
-          "start": 4304
-        },
-        {
-          "name": "test_i64_packing",
-          "start": 4402
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/type_packing.nr",
-      "source": "use crate::traits::Packable;\n\nglobal BOOL_PACKED_LEN: u32 = 1;\nglobal U8_PACKED_LEN: u32 = 1;\nglobal U16_PACKED_LEN: u32 = 1;\nglobal U32_PACKED_LEN: u32 = 1;\nglobal U64_PACKED_LEN: u32 = 1;\nglobal U128_PACKED_LEN: u32 = 1;\nglobal FIELD_PACKED_LEN: u32 = 1;\nglobal I8_PACKED_LEN: u32 = 1;\nglobal I16_PACKED_LEN: u32 = 1;\nglobal I32_PACKED_LEN: u32 = 1;\nglobal I64_PACKED_LEN: u32 = 1;\n\nimpl Packable for bool {\n    let N: u32 = BOOL_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> bool {\n        (fields[0] as u8) % 2 != 0\n    }\n}\n\nimpl Packable for u8 {\n    let N: u32 = U8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8\n    }\n}\n\nimpl Packable for u16 {\n    let N: u32 = U16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16\n    }\n}\n\nimpl Packable for u32 {\n    let N: u32 = U32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32\n    }\n}\n\nimpl Packable for u64 {\n    let N: u32 = U64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64\n    }\n}\n\nimpl Packable for u128 {\n    let N: u32 = U128_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u128\n    }\n}\n\nimpl Packable for Field {\n    let N: u32 = FIELD_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0]\n    }\n}\n\nimpl Packable for i8 {\n    let N: u32 = I8_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u8 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u8 as i8\n    }\n}\n\nimpl Packable for i16 {\n    let N: u32 = I16_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u16 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u16 as i16\n    }\n}\n\nimpl Packable for i32 {\n    let N: u32 = I32_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u32 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u32 as i32\n    }\n}\n\nimpl Packable for i64 {\n    let N: u32 = I64_PACKED_LEN;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        [self as u64 as Field]\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        fields[0] as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Packable for [T; M]\nwhere\n    T: Packable,\n{\n    let N: u32 = M * <T as Packable>::N;\n\n    #[inline_always]\n    fn pack(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n        for i in 0..M {\n            let serialized = self[i].pack();\n            for j in 0..<T as Packable>::N {\n                result[i * <T as Packable>::N + j] = serialized[j];\n            }\n        }\n        result\n    }\n\n    #[inline_always]\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::utils::reader::Reader::new(fields);\n        let result: [T; M] = std::mem::zeroed();\n        reader.read_struct_array::<T, <T as Packable>::N, M>(Packable::unpack, result)\n    }\n}\n\n#[test]\nfn test_u16_packing() {\n    let a: u16 = 10;\n    assert_eq(a, u16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i8_packing() {\n    let a: i8 = -10;\n    assert_eq(a, i8::unpack(a.pack()));\n}\n\n#[test]\nfn test_i16_packing() {\n    let a: i16 = -10;\n    assert_eq(a, i16::unpack(a.pack()));\n}\n\n#[test]\nfn test_i32_packing() {\n    let a: i32 = -10;\n    assert_eq(a, i32::unpack(a.pack()));\n}\n\n#[test]\nfn test_i64_packing() {\n    let a: i64 = -10;\n    assert_eq(a, i64::unpack(a.pack()));\n}\n"
-    },
     "239": {
       "function_locations": [
         {
@@ -1738,7 +1520,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
       "source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n        reader.read() != 0\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self);\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read()\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u8 as Field);\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u16 as Field);\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u32 as Field);\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u64 as Field);\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        for i in 0..M {\n            self[i].stream_serialize(writer);\n        }\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut result: [T; M] = std::mem::zeroed();\n        for i in 0..M {\n            result[i] = T::stream_deserialize(reader);\n        }\n        result\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write_bool(self.is_some());\n        if self.is_some() {\n            self.unwrap_unchecked().stream_serialize(writer);\n        } else {\n            writer.advance_offset(<T as Serialize>::N);\n        }\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        if reader.read_bool() {\n            Option::some(<T as Deserialize>::stream_deserialize(reader))\n        } else {\n            reader.advance_offset(<T as Deserialize>::N);\n            Option::none()\n        }\n    }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n    let N: u32 = SCALAR_SIZE;\n\n    fn serialize(self) -> [Field; SCALAR_SIZE] {\n        [self.lo, self.hi]\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.lo);\n        writer.write(self.hi);\n    }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n    let N: u32 = SCALAR_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { lo: fields[0], hi: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { lo: reader.read(), hi: reader.read() }\n    }\n}\n\nglobal POINT_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.x, self.y]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.x);\n        writer.write(self.y);\n    }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { x: fields[0], y: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { x: reader.read(), y: reader.read() }\n    }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n    let N: u32 = M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n        str::<Self::N>::from(u8_arr)\n    }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n    let N: u32 = M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.as_bytes().stream_serialize(writer);\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n        let payload_len = Self::N - 1;\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = reader.peek_offset(payload_len) as u32;\n\n        for i in 0..M {\n            if i < len {\n                new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n            }\n        }\n\n        // +1 for the length of the BoundedVec\n        reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n    let N: u32 = 0;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n        ()\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.storage().stream_serialize(writer);\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        writer.write_u32(self.len() as u32);\n    }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n    let mut slice = @[];\n    for i in 0..length {\n        slice = slice.push_back(f(i));\n    }\n    slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n    // `T0`, `T1`, `T2`\n    let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n    // `result0`, `result1`, `result2`\n    let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n    // `T0, T1, T2`\n    let field_generics = type_names.join(quote [,]);\n\n    // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n    let full_size_serialize = type_names\n        .map(|type_name| quote {\n        <$type_name as Serialize>::N\n    })\n        .join(quote [+]);\n\n    // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n    let full_size_deserialize = type_names\n        .map(|type_name| quote {\n        <$type_name as Deserialize>::N\n    })\n        .join(quote [+]);\n\n    // `T0: Serialize, T1: Serialize, T2: Serialize,`\n    let serialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Serialize,\n    })\n        .join(quote []);\n\n    // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n    let deserialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Deserialize,\n    })\n        .join(quote []);\n\n    // Statements to serialize each field\n    let serialized_fields = type_names\n        .mapi(|i, _type_name| quote {\n            $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n    })\n        .join(quote []);\n\n    // Statements to deserialize each field\n    let deserialized_fields = type_names\n        .mapi(|i, type_name| {\n            let result_name = result_names[i];\n            quote {\n            let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n        }\n        })\n        .join(quote []);\n    let deserialize_results = result_names.join(quote [,]);\n\n    quote {\n        impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n            let N: u32 = $full_size_serialize;\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                self.stream_serialize(&mut writer);\n                writer.finish()\n            }\n\n            #[inline_always]\n            fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n                $serialized_fields\n            }\n        }\n\n        impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n            let N: u32 = $full_size_deserialize;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n    \n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $deserialized_fields\n                ($deserialize_results)\n            }\n        }\n    }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n    T1: Serialize,\n{\n    let N: u32 = <T1 as Serialize>::N;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.0.stream_serialize(writer);\n    }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n    T1: Deserialize,\n{\n    let N: u32 = <T1 as Deserialize>::N;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::reader::Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        (<T1 as Deserialize>::stream_deserialize(reader),)\n    }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n    use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
     },
-    "41": {
+    "40": {
       "function_locations": [
         {
           "name": "Option<T>::none",
@@ -1836,7 +1618,7 @@
       "path": "std/option.nr",
       "source": "use crate::cmp::{Eq, Ord, Ordering};\nuse crate::default::Default;\nuse crate::hash::{Hash, Hasher};\n\n/// Represents a value of type T or its absence.\n/// Use `Option::some(value)` to construct a value or `Option::none()` to record the absence of one.\npub struct Option<T> {\n    _is_some: bool,\n    _value: T,\n}\n\nimpl<T> Option<T> {\n    /// Constructs a None value\n    pub fn none() -> Self {\n        Self { _is_some: false, _value: crate::mem::zeroed() }\n    }\n\n    /// Constructs a Some wrapper around the given value\n    pub fn some(_value: T) -> Self {\n        Self { _is_some: true, _value }\n    }\n\n    /// True if this Option is None\n    pub fn is_none(&self) -> bool {\n        !self._is_some\n    }\n\n    /// True if this Option is Some\n    pub fn is_some(&self) -> bool {\n        self._is_some\n    }\n\n    /// Asserts `self.is_some()` and returns the wrapped value.\n    pub fn unwrap(self) -> T {\n        assert(self._is_some);\n        self._value\n    }\n\n    /// Returns the inner value without asserting `self.is_some()`\n    /// Note that if `self` is `None`, there is no guarantee what value will be returned,\n    /// only that it will be of type `T`.\n    pub fn unwrap_unchecked(self) -> T {\n        self._value\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, returns the given default value.\n    pub fn unwrap_or(self, default: T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default\n        }\n    }\n\n    /// Returns the wrapped value if `self.is_some()`. Otherwise, calls the given function to return\n    /// a default value.\n    pub fn unwrap_or_else<Env>(self, default: fn[Env]() -> T) -> T {\n        if self._is_some {\n            self._value\n        } else {\n            default()\n        }\n    }\n\n    /// Asserts `self.is_some()` with a provided custom message and returns the contained `Some` value\n    pub fn expect<let N: u32, MessageTypes>(self, message: fmtstr<N, MessageTypes>) -> T {\n        assert(self.is_some(), message);\n        self._value\n    }\n\n    /// If self is `Some(x)`, this returns `Some(f(x))`. Otherwise, this returns `None`.\n    pub fn map<U, Env>(self, f: fn[Env](T) -> U) -> Option<U> {\n        if self._is_some {\n            Option::some(f(self._value))\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns the given default value.\n    pub fn map_or<U, Env>(self, default: U, f: fn[Env](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default\n        }\n    }\n\n    /// If self is `Some(x)`, this returns `f(x)`. Otherwise, this returns `default()`.\n    pub fn map_or_else<U, Env1, Env2>(self, default: fn[Env1]() -> U, f: fn[Env2](T) -> U) -> U {\n        if self._is_some {\n            f(self._value)\n        } else {\n            default()\n        }\n    }\n\n    /// Returns None if self is None. Otherwise, this returns `other`.\n    pub fn and(self, other: Self) -> Self {\n        if self.is_none() {\n            Option::none()\n        } else {\n            other\n        }\n    }\n\n    /// If self is None, this returns None. Otherwise, this calls the given function\n    /// with the Some value contained within self, and returns the result of that call.\n    ///\n    /// In some languages this function is called `flat_map` or `bind`.\n    pub fn and_then<U, Env>(self, f: fn[Env](T) -> Option<U>) -> Option<U> {\n        if self._is_some {\n            f(self._value)\n        } else {\n            Option::none()\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `other`.\n    pub fn or(self, other: Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            other\n        }\n    }\n\n    /// If self is Some, return self. Otherwise, return `default()`.\n    pub fn or_else<Env>(self, default: fn[Env]() -> Self) -> Self {\n        if self._is_some {\n            self\n        } else {\n            default()\n        }\n    }\n\n    // If only one of the two Options is Some, return that option.\n    // Otherwise, if both options are Some or both are None, None is returned.\n    pub fn xor(self, other: Self) -> Self {\n        if self._is_some {\n            if other._is_some {\n                Option::none()\n            } else {\n                self\n            }\n        } else if other._is_some {\n            other\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Returns `Some(x)` if self is `Some(x)` and `predicate(x)` is true.\n    /// Otherwise, this returns `None`\n    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {\n        if self._is_some {\n            if predicate(self._value) {\n                self\n            } else {\n                Option::none()\n            }\n        } else {\n            Option::none()\n        }\n    }\n\n    /// Flattens an Option<Option<T>> into a Option<T>.\n    /// This returns None if the outer Option is None. Otherwise, this returns the inner Option.\n    pub fn flatten(option: Option<Option<T>>) -> Option<T> {\n        if option._is_some {\n            option._value\n        } else {\n            Option::none()\n        }\n    }\n}\n\nimpl<T> Default for Option<T> {\n    fn default() -> Self {\n        Option::none()\n    }\n}\n\nimpl<T> Eq for Option<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        if self._is_some == other._is_some {\n            if self._is_some {\n                self._value == other._value\n            } else {\n                true\n            }\n        } else {\n            false\n        }\n    }\n}\n\nimpl<T> Hash for Option<T>\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self._is_some.hash(state);\n        if self._is_some {\n            self._value.hash(state);\n        }\n    }\n}\n\n// For this impl we're declaring Option::none < Option::some\nimpl<T> Ord for Option<T>\nwhere\n    T: Ord,\n{\n    fn cmp(self, other: Self) -> Ordering {\n        if self._is_some {\n            if other._is_some {\n                self._value.cmp(other._value)\n            } else {\n                Ordering::greater()\n            }\n        } else if other._is_some {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n"
     },
-    "42": {
+    "41": {
       "function_locations": [
         {
           "name": "panic",
@@ -1846,6 +1628,40 @@
       "path": "std/panic.nr",
       "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n"
     },
+    "49": {
+      "function_locations": [
+        {
+          "name": "ContractInstanceRegistry::ContractInstancePublished::serialize_non_standard",
+          "start": 1995
+        },
+        {
+          "name": "ContractInstanceRegistry::publish_for_public_execution",
+          "start": 5010
+        },
+        {
+          "name": "ContractInstanceRegistry::update",
+          "start": 9119
+        },
+        {
+          "name": "ContractInstanceRegistry::set_update_delay",
+          "start": 11330
+        },
+        {
+          "name": "ContractInstanceRegistry::get_update_delay",
+          "start": 12633
+        },
+        {
+          "name": "ContractInstanceRegistry::public_dispatch",
+          "start": 13785
+        },
+        {
+          "name": "ContractInstanceRegistry::Storage<Context>::init",
+          "start": 14918
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
+      "source": "/// Protocol contract responsible for deploying contract instances and managing contract upgrades.\n///\n/// In Aztec, contracts are split into *classes* (code, registered via ContractClassRegistry) and *instances*\n/// (deployments of a class at a unique address). This contract handles contract instance publishing and contract\n/// updates (updating instance to a new class).\npub contract ContractInstanceRegistry {\n    use aztec::{\n        context::{PrivateContext, PublicContext},\n        hash::hash_args,\n        nullifier::utils::compute_nullifier_existence_request,\n        oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, PartialAddress},\n            constants::{\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n            },\n            contract_class_id::ContractClassId,\n            public_keys::PublicKeys,\n            traits::{Deserialize, Serialize, ToField},\n            utils::reader::Reader,\n        },\n        state_vars::{DelayedPublicMutable, Map, StateVariable},\n    };\n\n    #[abi(events)]\n    struct ContractInstancePublished {\n        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        immutables_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // Custom serialization is required because:\n    // - npk_m, ovpk_m, tpk_m, mspk_m, fbpk_m are exposed only as hashes so we serialize the hashes\n    //   directly.\n    // - For ivpk_m we drop the `is_infinite` flag (we assume non-infinity).\n    impl ContractInstancePublished {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.immutables_hash,\n                self.public_keys.npk_m_hash,\n                self.public_keys.ivpk_m.inner.x,\n                self.public_keys.ivpk_m.inner.y,\n                self.public_keys.ovpk_m_hash,\n                self.public_keys.tpk_m_hash,\n                self.public_keys.mspk_m_hash,\n                self.public_keys.fbpk_m_hash,\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[abi(events)]\n    #[derive(Serialize)]\n    struct ContractInstanceUpdated {\n        CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        timestamp_of_change: u64,\n    }\n\n    struct Storage<Context> {\n        /// Map from contract instance address to a `DelayedPublicMutable` holding the updated contract class ID.\n        updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    /// Publishes a new contract instance.\n    ///\n    /// The caller provides deployment parameters (salt, class_id, init_hash, immutables_hash, public_keys,\n    /// universal_deploy).\n    /// The `universal_deploy` flag controls whether the deployer address is bound into the contract address:\n    /// when true, deployer is zero (anyone can deploy the same instance); when false, deployer is the caller.\n    ///\n    /// This function:\n    /// 1. Verifies the contract class is registered in ContractClassRegistry (nullifier existence check).\n    /// 2. Validates `ivpk_m` is on the Grumpkin curve and not the point at infinity (preventing AVM DoS via an invalid\n    /// point). `npk_m`, `ovpk_m`, `tpk_m`, `mspk_m`, and `fbpk_m` are exposed only as hashes and are not validated\n    /// in-circuit.\n    /// 3. Computes the deterministic contract address from the deployment parameters.\n    /// 4. Emits the address as a nullifier (proving publication preventing duplicate deployment)\n    ///    --> this address nullifier is then checked to exist by the AVM upon public function execution (if it doesn't\n    ///        exist AVM reverts)\n    /// 5. Broadcasts a `ContractInstancePublished` event so nodes can reconstruct the instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn publish_for_public_execution(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        immutables_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // body, I have removed that check.\n        assert_compatible_oracle_version();\n\n        // 4 prefix fields (salt, class_id, init_hash, immutables_hash) + 7 public-key fields\n        // + 1 universal_deploy flag = 12.\n        let serialized_params: [Field; 12] = [salt, contract_class_id.to_field(), initialization_hash, immutables_hash]\n            .concat(public_keys.serialize())\n            .concat([universal_deploy.to_field()]);\n\n        let args_hash: Field = hash_args(serialized_params);\n        let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        // Verify the contract class is registered by checking for its nullifier at the ContractClassRegistry address.\n        let nullifier_existence_request = compute_nullifier_existence_request(\n            contract_class_id.to_field(),\n            CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n        );\n        context.assert_nullifier_exists(nullifier_existence_request);\n\n        // For universal deployments, deployer is zero so the resulting address is the same regardless of who initiates\n        // deployment.\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.maybe_msg_sender().unwrap()\n        };\n\n        let partial_address = PartialAddress::compute(\n            contract_class_id,\n            salt,\n            initialization_hash,\n            deployer,\n            immutables_hash,\n        );\n\n        // Validate `ivpk_m` is on the Grumpkin curve and is not the point at infinity (preventing AVM\n        // DoS attacks). The other five master keys are exposed as hashes and have no\n        // curve-point to validate here.\n        public_keys.validate_on_curve();\n        public_keys.validate_non_infinity();\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit address as nullifier: prevents duplicate deployment and proves publication.\n        // We use no domain separators because these are the only nullifiers this contract uses.\n        context.push_nullifier(address.to_field());\n\n        // Broadcast deployment event. Version 2 carries hashes for npk/ovpk/tpk/mspk/fbpk and the\n        // affine coordinates of ivpk only; see `serialize_non_standard`.\n        let event = ContractInstancePublished {\n            CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            immutables_hash,\n            salt,\n            deployer,\n            version: 2,\n        };\n        let payload = event.serialize_non_standard();\n        debug_log_format(\"ContractInstancePublished: {}\", payload);\n        // We pad the payload with zeros to match the length required by emit_private_log (PRIVATE_LOG_SIZE_IN_FIELDS).\n        // Since the log is not encrypted, padding with zero rather than a random value is acceptable (we don't care\n        // about privacy here).\n        let padded_log = payload.concat([0]);\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Schedules an upgrade of the calling contract instance to a new contract class.\n    ///\n    /// The change is time-delayed via `DelayedPublicMutable` and only takes effect after the configured\n    /// delay has elapsed. Only the contract instance itself can call this function (msg.sender == address).\n    ///\n    /// This function:\n    /// 1. Verifies msg.sender is a deployed contract (its address nullifier exists).\n    /// 2. Verifies the new class is registered in ContractClassRegistry.\n    /// 3. Schedules the class ID change and emits a `ContractInstanceUpdated` event.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn update(new_contract_class_id: ContractClassId) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let address = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n        // information through registration, which is safe - we just need this information to be _eventually_\n        // available.\n        assert(\n            context.nullifier_exists_unsafe(new_contract_class_id.to_field(), CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update =\n            storage.updated_class_ids.at(address).schedule_and_get_value_change(new_contract_class_id);\n        let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            timestamp_of_change,\n        };\n        context.emit_public_log(event);\n    }\n\n    /// Schedules a change to the upgrade delay for the calling contract instance. The delay change is\n    /// itself delayed (preventing atomically reducing delay + scheduling an instant upgrade). The new\n    /// delay must be at least `MINIMUM_UPDATE_DELAY`.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn set_update_delay(new_update_delay: u64) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let msg_sender = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n    }\n\n    /// Returns the current update delay for the calling contract instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn get_update_delay() -> pub u64 {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n        // MACRO CODE END\n\n        storage.updated_class_ids.at(avm::sender()).get_current_delay()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    global UPDATE_SELECTOR: Field = comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n    global SET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n    global GET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == UPDATE_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: ContractClassId = <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n            update(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == SET_UPDATE_DELAY_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n            set_update_delay(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == GET_UPDATE_DELAY_SELECTOR {\n            let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n            avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct publish_for_public_execution_parameters {\n        pub _salt: Field,\n        pub _contract_class_id: ContractClassId,\n        pub _initialization_hash: Field,\n        pub _immutables_hash: Field,\n        pub _public_keys: PublicKeys,\n        pub _universal_deploy: bool,\n    }\n\n    pub struct update_parameters {\n        pub _new_contract_class_id: ContractClassId,\n    }\n\n    pub struct set_update_delay_parameters {\n        pub _new_update_delay: u64,\n    }\n\n    pub struct get_update_delay_parameters {}\n\n    #[abi(functions)]\n    pub struct publish_for_public_execution_abi {\n        parameters: publish_for_public_execution_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct update_abi {\n        parameters: update_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct set_update_delay_abi {\n        parameters: set_update_delay_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct get_update_delay_abi {\n        parameters: get_update_delay_parameters,\n        return_type: u64,\n    }\n}\n"
+    },
     "5": {
       "function_locations": [
         {
@@ -2108,41 +1924,7 @@
       "path": "std/cmp.nr",
       "source": "use crate::meta::ctstring::AsCtString;\nuse crate::meta::derive_via;\n\n/// Compare two values for equality\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields_as_written().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { $crate::cmp::Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u128 {\n    fn eq(self, other: u128) -> bool {\n        self == other\n    }\n}\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        if result {\n            for i in 0..self.len() {\n                result &= self[i].eq(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\ncomptime fn make_tuple_eq_body(n: u32) -> Quoted {\n    let mut body = f\"self.0.eq(other.0)\".as_ctstring();\n    for i in 1u32..n {\n        body = body.append_fmtstr(f\" & self.{i}.eq(other.{i})\");\n    }\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Eq, B: Eq> Eq for (A, B) {\n    fn eq(self, other: (A, B)) -> bool {\n        make_tuple_eq_body!(2u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C) {\n    fn eq(self, other: (A, B, C)) -> bool {\n        make_tuple_eq_body!(3u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for (A, B, C, D) {\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        make_tuple_eq_body!(4u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for (A, B, C, D, E) {\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        make_tuple_eq_body!(5u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq> Eq for (A, B, C, D, E, F) {\n    fn eq(self, other: (A, B, C, D, E, F)) -> bool {\n        make_tuple_eq_body!(6u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq> Eq for (A, B, C, D, E, F, G) {\n    fn eq(self, other: (A, B, C, D, E, F, G)) -> bool {\n        make_tuple_eq_body!(7u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for (A, B, C, D, E, F, G, H) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H)) -> bool {\n        make_tuple_eq_body!(8u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq> Eq for (A, B, C, D, E, F, G, H, I) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I)) -> bool {\n        make_tuple_eq_body!(9u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq> Eq for (A, B, C, D, E, F, G, H, I, J) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J)) -> bool {\n        make_tuple_eq_body!(10u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> bool {\n        make_tuple_eq_body!(11u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> bool {\n        make_tuple_eq_body!(12u32)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\n/// A value with three states: `Ordering::less()`, `Ordering::equal()` or `Ordering::greater()`.\n/// Most often used to encode the result of a comparison operation.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n/// Compare one object to another, returning whether it is less-than, equal-to,\n/// or greater-than the other object.\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::cmp::Ord };\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == $crate::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = $crate::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n    fn cmp(self, other: u128) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let self_len = self.len();\n        let other_len = other.len();\n        let min_len = if self_len < other_len {\n            self_len\n        } else {\n            other_len\n        };\n\n        let mut result = Ordering::equal();\n        for i in 0..min_len {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self_len.cmp(other_len)\n        }\n    }\n}\n\ncomptime fn make_tuple_ord_body(n: u32) -> Quoted {\n    let last = n - 1u32;\n    let mut body = if last == 1 {\n        f\"let result = self.0.cmp(other.0);\".as_ctstring()\n    } else {\n        f\"let mut result = self.0.cmp(other.0);\".as_ctstring()\n    };\n    for i in 1u32..last {\n        body = body.append_fmtstr(\n            f\" if result == Ordering::equal() {{ result = self.{i}.cmp(other.{i}); }}\",\n        );\n    }\n    body = body.append_fmtstr(\n        f\" if result != Ordering::equal() {{ result }} else {{ self.{last}.cmp(other.{last}) }}\",\n    );\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Ord, B: Ord> Ord for (A, B) {\n    fn cmp(self, other: (A, B)) -> Ordering {\n        make_tuple_ord_body!(2u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C) {\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        make_tuple_ord_body!(3u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D) {\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        make_tuple_ord_body!(4u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E) {\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        make_tuple_ord_body!(5u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F) {\n    fn cmp(self, other: (A, B, C, D, E, F)) -> Ordering {\n        make_tuple_ord_body!(6u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G) {\n    fn cmp(self, other: (A, B, C, D, E, F, G)) -> Ordering {\n        make_tuple_ord_body!(7u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H)) -> Ordering {\n        make_tuple_ord_body!(8u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I)) -> Ordering {\n        make_tuple_ord_body!(9u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J)) -> Ordering {\n        make_tuple_ord_body!(10u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> Ordering {\n        make_tuple_ord_body!(11u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering {\n        make_tuple_ord_body!(12u32)\n    }\n}\n\n/// Compares and returns the maximum of two values.\n///\n/// Returns the second argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::max(1, 2), 2);\n/// assert_eq(cmp::max(2, 2), 2);\n/// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n/// Compares and returns the minimum of two values.\n///\n/// Returns the first argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::min(1, 2), 1);\n/// assert_eq(cmp::min(2, 2), 2);\n/// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use super::{Eq, max, min, Ord};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0_u64, 1), 0);\n        assert_eq(min(0_u64, 0), 0);\n        assert_eq(min(1_u64, 1), 1);\n        assert_eq(min(255_u8, 0), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0_u64, 1), 1);\n        assert_eq(max(0_u64, 0), 0);\n        assert_eq(max(1_u64, 1), 1);\n        assert_eq(max(255_u8, 0), 255);\n    }\n\n    #[test]\n    fn correctly_handles_unequal_length_vectors() {\n        let vector_1 = [0, 1, 2, 3].as_vector();\n        let vector_2 = [0, 1, 2].as_vector();\n        assert(!vector_1.eq(vector_2));\n    }\n\n    #[test]\n    fn lexicographic_ordering_for_vectors() {\n        assert(\n            [2_u32].as_vector().cmp([1_u32, 1_u32, 1_u32].as_vector())\n                == super::Ordering::greater(),\n        );\n        assert(\n            [1_u32, 2_u32].as_vector().cmp([1_u32, 2_u32, 3_u32].as_vector())\n                == super::Ordering::less(),\n        );\n    }\n}\n"
     },
-    "50": {
-      "function_locations": [
-        {
-          "name": "ContractInstanceRegistry::ContractInstancePublished::serialize_non_standard",
-          "start": 1908
-        },
-        {
-          "name": "ContractInstanceRegistry::publish_for_public_execution",
-          "start": 4796
-        },
-        {
-          "name": "ContractInstanceRegistry::update",
-          "start": 8513
-        },
-        {
-          "name": "ContractInstanceRegistry::set_update_delay",
-          "start": 10807
-        },
-        {
-          "name": "ContractInstanceRegistry::get_update_delay",
-          "start": 12110
-        },
-        {
-          "name": "ContractInstanceRegistry::public_dispatch",
-          "start": 13270
-        },
-        {
-          "name": "ContractInstanceRegistry::Storage<Context>::init",
-          "start": 14435
-        }
-      ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
-      "source": "/// Protocol contract responsible for deploying contract instances and managing contract upgrades.\n///\n/// In Aztec, contracts are split into *classes* (code, registered via ContractClassRegistry) and *instances*\n/// (deployments of a class at a unique address). This contract handles contract instance publishing and contract\n/// updates (updating instance to a new class).\npub contract ContractInstanceRegistry {\n    use aztec::{\n        context::{PrivateContext, PublicContext},\n        hash::hash_args,\n        nullifier::utils::compute_nullifier_existence_request,\n        oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, PartialAddress},\n            constants::{\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n            },\n            contract_class_id::ContractClassId,\n            public_keys::PublicKeys,\n            traits::{Deserialize, Serialize, ToField},\n            utils::reader::Reader,\n        },\n        state_vars::{DelayedPublicMutable, Map, StateVariable},\n    };\n\n    #[abi(events)]\n    struct ContractInstancePublished {\n        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // Custom serialization is required because we don't want to waste one field for the `is_infinite` flag of public\n    // key points (public key points will never be the infinity point).\n    impl ContractInstancePublished {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.public_keys.npk_m.serialize()[0],\n                self.public_keys.npk_m.serialize()[1],\n                self.public_keys.ivpk_m.serialize()[0],\n                self.public_keys.ivpk_m.serialize()[1],\n                self.public_keys.ovpk_m.serialize()[0],\n                self.public_keys.ovpk_m.serialize()[1],\n                self.public_keys.tpk_m.serialize()[0],\n                self.public_keys.tpk_m.serialize()[1],\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[abi(events)]\n    #[derive(Serialize)]\n    struct ContractInstanceUpdated {\n        CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        timestamp_of_change: u64,\n    }\n\n    struct Storage<Context> {\n        /// Map from contract instance address to a `DelayedPublicMutable` holding the updated contract class ID.\n        updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    /// Publishes a new contract instance.\n    ///\n    /// The caller provides deployment parameters (salt, class_id, init_hash, public_keys, universal_deploy).\n    /// The `universal_deploy` flag controls whether the deployer address is bound into the contract address:\n    /// when true, deployer is zero (anyone can deploy the same instance); when false, deployer is the caller.\n    ///\n    /// This function:\n    /// 1. Verifies the contract class is registered in ContractClassRegistry (nullifier existence check).\n    /// 2. Validates public key points are on the Grumpkin curve (preventing AVM DoS via invalid points).\n    /// 3. Computes the deterministic contract address from the deployment parameters.\n    /// 4. Emits the address as a nullifier (proving publication preventing duplicate deployment)\n    ///    --> this address nullifier is then checked to exist by the AVM upon public function execution (if it doesn't\n    ///        exist AVM reverts)\n    /// 5. Broadcasts a `ContractInstancePublished` event so nodes can reconstruct the instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn publish_for_public_execution(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // body, I have removed that check.\n        assert_compatible_oracle_version();\n\n        let serialized_params: [Field; 16] = [\n            salt,\n            contract_class_id.to_field(),\n            initialization_hash,\n        ]\n            .concat(public_keys.serialize())\n            .concat([universal_deploy.to_field()]);\n\n        let args_hash: Field = hash_args(serialized_params);\n        let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        // Verify the contract class is registered by checking for its nullifier at the ContractClassRegistry address.\n        let nullifier_existence_request = compute_nullifier_existence_request(\n            contract_class_id.to_field(),\n            CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n        );\n        context.assert_nullifier_exists(nullifier_existence_request);\n\n        // For universal deployments, deployer is zero so the resulting address is the same regardless of who initiates\n        // deployment.\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.maybe_msg_sender().unwrap()\n        };\n\n        let partial_address =\n            PartialAddress::compute(contract_class_id, salt, initialization_hash, deployer);\n\n        // Validate public key points lie on the Grumpkin curve and are non-0 to prevent AVM DoS attacks.\n        public_keys.validate_on_curve();\n        public_keys.validate_non_infinity();\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit address as nullifier: prevents duplicate deployment and proves publication.\n        // We use no domain separators because these are the only nullifiers this contract uses.\n        context.push_nullifier(address.to_field());\n\n        // Broadcast deployment event. Uses non-standard serialization (2 fields per point,\n        // omitting is_infinite) for TypeScript SDK compatibility.\n        let event = ContractInstancePublished {\n            CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            salt,\n            deployer,\n            version: 1,\n        };\n        let payload = event.serialize_non_standard();\n        debug_log_format(\"ContractInstancePublished: {}\", payload);\n        // We pad the payload with [0] to match the length required by emit_private_log. Since the log is not\n        // encrypted, padding with zero rather than a random value is acceptable (we don't care about privacy here).\n        let padded_log = payload.concat([0]);\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Schedules an upgrade of the calling contract instance to a new contract class.\n    ///\n    /// The change is time-delayed via `DelayedPublicMutable` and only takes effect after the configured\n    /// delay has elapsed. Only the contract instance itself can call this function (msg.sender == address).\n    ///\n    /// This function:\n    /// 1. Verifies msg.sender is a deployed contract (its address nullifier exists).\n    /// 2. Verifies the new class is registered in ContractClassRegistry.\n    /// 3. Schedules the class ID change and emits a `ContractInstanceUpdated` event.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn update(new_contract_class_id: ContractClassId) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] =\n                    avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let address = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n        // information through registration, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(\n                new_contract_class_id.to_field(),\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n            ),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update = storage\n            .updated_class_ids\n            .at(address)\n            .schedule_and_get_value_change(new_contract_class_id);\n        let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            timestamp_of_change,\n        };\n        context.emit_public_log(event);\n    }\n\n    /// Schedules a change to the upgrade delay for the calling contract instance. The delay change is\n    /// itself delayed (preventing atomically reducing delay + scheduling an instant upgrade). The new\n    /// delay must be at least `MINIMUM_UPDATE_DELAY`.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn set_update_delay(new_update_delay: u64) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let msg_sender = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n    }\n\n    /// Returns the current update delay for the calling contract instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn get_update_delay() -> pub u64 {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n        // MACRO CODE END\n\n        storage.updated_class_ids.at(avm::sender()).get_current_delay()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    global UPDATE_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n    global SET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n    global GET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == UPDATE_SELECTOR {\n            let input_calldata: [Field; 1] =\n                avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: ContractClassId =\n                <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n            update(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == SET_UPDATE_DELAY_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n            set_update_delay(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == GET_UPDATE_DELAY_SELECTOR {\n            let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n            avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct publish_for_public_execution_parameters {\n        pub _salt: Field,\n        pub _contract_class_id: ContractClassId,\n        pub _initialization_hash: Field,\n        pub _public_keys: PublicKeys,\n        pub _universal_deploy: bool,\n    }\n\n    pub struct update_parameters {\n        pub _new_contract_class_id: ContractClassId,\n    }\n\n    pub struct set_update_delay_parameters {\n        pub _new_update_delay: u64,\n    }\n\n    pub struct get_update_delay_parameters {}\n\n    #[abi(functions)]\n    pub struct publish_for_public_execution_abi {\n        parameters: publish_for_public_execution_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct update_abi {\n        parameters: update_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct set_update_delay_abi {\n        parameters: set_update_delay_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct get_update_delay_abi {\n        parameters: get_update_delay_parameters,\n        return_type: u64,\n    }\n}\n"
-    },
-    "57": {
+    "56": {
       "function_locations": [
         {
           "name": "PrivateContext::new",
@@ -2244,7 +2026,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
       "source": "use crate::{\n    context::{inputs::PrivateContextInputs, NullifierExistenceRequest, ReturnsHash},\n    hash::hash_args,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        call_private_function::call_private_function_internal,\n        public_call::validate_public_calldata,\n        tx_phase::{in_revertible_phase, notify_revertible_phase_start},\n        execution_cache,\n        logs::notify_created_contract_class_log,\n        nullifiers::notify_created_nullifier,\n    },\n};\nuse crate::protocol::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, MAX_CONTRACT_CLASS_LOGS_PER_CALL,\n        MAX_ENQUEUED_CALLS_PER_CALL, MAX_TX_LIFETIME, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        NULL_MSG_SENDER_CONTRACT_ADDRESS, PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    hash::poseidon2_hash,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    side_effect::{Counted, scoped::Scoped},\n    traits::Empty,\n    utils::arrays::{ClaimedLengthArray, trimmed_array_length_hint},\n};\n\n/// Minimal PrivateContext for protocol contracts going to audit.\n/// Contains only the methods actually used by: fee_juice, auth_registry, contract_class_registry, contract_instance_registry\n#[derive(Eq)]\npub struct PrivateContext {\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub expiration_timestamp: u64,\n\n    pub nullifier_read_requests: BoundedVec<Scoped<Counted<Field>>, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n\n    pub nullifiers: BoundedVec<Counted<Nullifier>, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub anchor_block_header: BlockHeader,\n\n    pub private_logs: BoundedVec<Counted<PrivateLogData>, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    pub expected_non_revertible_side_effect_counter: u32,\n    pub expected_revertible_side_effect_counter: u32,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            expiration_timestamp: inputs.anchor_block_header.global_variables.timestamp\n            + MAX_TX_LIFETIME,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            anchor_block_header: inputs.anchor_block_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call (similar to msg.sender in Solidity).\n    pub fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.inputs.call_context.msg_sender;\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the contract address of the current function being executed.\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    /// Returns the protocol version.\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    /// Returns the gas settings for the current transaction.\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    /// Returns the function selector of the currently executing function.\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    /// Returns the anchor block header.\n    pub fn get_anchor_block_header(self) -> BlockHeader {\n        self.anchor_block_header\n    }\n\n    /// Sets the hash of the return values for this private function.\n    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {\n        let return_hash = hash_args(serialized_return_values);\n        self.return_hash = return_hash;\n        execution_cache::store(serialized_return_values, return_hash);\n    }\n\n    /// Builds the PrivateCircuitPublicInputs for this private function.\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            expiration_timestamp: self.expiration_timestamp,\n            note_hash_read_requests: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifier_read_requests: ClaimedLengthArray::from_bounded_vec(\n                self.nullifier_read_requests,\n            ),\n            key_validation_requests_and_separators: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            note_hashes: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifiers: ClaimedLengthArray::from_bounded_vec(self.nullifiers),\n            private_call_requests: ClaimedLengthArray::from_bounded_vec(self.private_call_requests),\n            public_call_requests: ClaimedLengthArray::from_bounded_vec(self.public_call_requests),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: ClaimedLengthArray::from_bounded_vec(self.l2_to_l1_msgs),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: ClaimedLengthArray::from_bounded_vec(self.private_logs),\n            contract_class_logs_hashes: ClaimedLengthArray::from_bounded_vec(\n                self.contract_class_logs_hashes,\n            ),\n            anchor_block_header: self.anchor_block_header,\n            tx_context: self.inputs.tx_context,\n            expected_non_revertible_side_effect_counter: self\n                .expected_non_revertible_side_effect_counter,\n            expected_revertible_side_effect_counter: self.expected_revertible_side_effect_counter,\n        }\n    }\n\n    /// Declares the end of the \"setup phase\" of this tx. Used by fee_juice.\n    pub fn end_setup(&mut self) {\n        self.side_effect_counter += 1;\n        self.min_revertible_side_effect_counter = self.next_counter();\n        notify_revertible_phase_start(self.min_revertible_side_effect_counter);\n    }\n\n    pub fn in_revertible_phase(&mut self) -> bool {\n        let current_counter = self.side_effect_counter;\n\n        // Safety: Kernel will validate that the claim is correct by validating the expected counters.\n        let is_revertible =\n            unsafe { in_revertible_phase(current_counter) };\n\n        if is_revertible {\n            if (self.expected_revertible_side_effect_counter == 0)\n                | (current_counter < self.expected_revertible_side_effect_counter) {\n                self.expected_revertible_side_effect_counter = current_counter;\n            }\n        } else if current_counter > self.expected_non_revertible_side_effect_counter {\n            self.expected_non_revertible_side_effect_counter = current_counter;\n        }\n\n        is_revertible\n    }\n\n    /// Sets a deadline for when this transaction must be included in a block.\n    pub fn set_expiration_timestamp(&mut self, expiration_timestamp: u64) {\n        self.expiration_timestamp = std::cmp::min(self.expiration_timestamp, expiration_timestamp);\n    }\n\n    /// Pushes a new nullifier. Used by class_registry and instance_registry.\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(Nullifier { value: nullifier, note_hash: 0 }.count(self.next_counter()));\n    }\n\n    /// Asserts that a nullifier has been emitted. Used by instance_registry.\n    pub fn assert_nullifier_exists(\n        &mut self,\n        nullifier_existence_request: NullifierExistenceRequest,\n    ) {\n        let nullifier = nullifier_existence_request.nullifier();\n        let contract_address =\n            nullifier_existence_request.maybe_contract_address().unwrap_or(AztecAddress::zero());\n\n        let request = Scoped::new(\n            Counted::new(nullifier, self.next_counter()),\n            contract_address,\n        );\n\n        self.nullifier_read_requests.push(request);\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2). Used by fee_juice.\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let nullifier = process_l1_to_l2_message(\n            self.anchor_block_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n\n    /// Emits a private log. Used by instance_registry.\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0 }\n            .count(counter);\n        self.private_logs.push(private_log);\n    }\n\n    /// Emits a contract class log. Used by class_registry.\n    pub fn emit_contract_class_log<let N: u32>(&mut self, log: [Field; N]) {\n        let contract_address = self.this_address();\n        let counter = self.next_counter();\n\n        let log_to_emit: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS] =\n            log.concat([0; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - N]);\n        // Safety: The below length is constrained in the base rollup, which will make sure that all the fields beyond\n        // length are zero. However, it won't be able to check that we didn't add extra padding (trailing zeroes) or\n        // that we cut trailing zeroes from the end.\n        let length = unsafe { trimmed_array_length_hint(log_to_emit) };\n        // We hash the entire padded log to ensure a user cannot pass a shorter length and so emit incorrect shorter\n        // bytecode.\n        let log_hash = poseidon2_hash(log_to_emit);\n        // Safety: the below only exists to broadcast the raw log, so we can provide it to the base rollup later to be\n        // constrained.\n        unsafe {\n            notify_created_contract_class_log(contract_address, log_to_emit, length, counter);\n        }\n\n        self.contract_class_logs_hashes.push(LogHash { value: log_hash, length: length }.count(\n            counter,\n        ));\n    }\n\n    /// Makes a read-only call to a private function. Used by auth_registry for authwit.\n    pub fn static_call_private_function<let ArgsCount: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ArgsCount],\n    ) -> ReturnsHash {\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    /// Enqueues a call to a public function with a calldata hash. Used by fee_juice and auth_registry.\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n        hide_msg_sender: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        validate_public_calldata(calldata_hash);\n\n        let msg_sender = if hide_msg_sender {\n            NULL_MSG_SENDER_CONTRACT_ADDRESS\n        } else {\n            self.this_address()\n        };\n\n        let call_request =\n            PublicCallRequest { msg_sender, contract_address, is_static_call, calldata_hash };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            expiration_timestamp: 0,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            anchor_block_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n}\n"
     },
-    "58": {
+    "57": {
       "function_locations": [
         {
           "name": "<impl Eq for PublicContext>::eq",
@@ -2374,7 +2156,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
       "source": "use crate::{\n    context::gas::GasOpts,\n    hash::{\n        compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n        compute_siloed_nullifier,\n    },\n    oracle::avm,\n};\nuse crate::protocol::{\n    abis::function_selector::FunctionSelector,\n    address::{AztecAddress, EthAddress},\n    constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n    traits::{Empty, FromField, Packable, Serialize, ToField},\n};\n\n/// Minimal PublicContext for protocol contracts going to audit.\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    pub fn emit_public_log<T>(_self: Self, log: T)\n    where\n        T: Serialize,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_public_log(Serialize::serialize(log).as_vector()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::note_hash_exists(note_hash, leaf_index) }\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe { avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64) }\n    }\n\n    /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n    pub fn nullifier_exists_unsafe(\n        _self: Self,\n        unsiloed_nullifier: Field,\n        contract_address: AztecAddress,\n    ) -> bool {\n        let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::nullifier_exists(siloed_nullifier) }\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2).\n    pub fn consume_l1_to_l2_message(\n        self: Self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists_unsafe(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    /// Sends an \"L2 -> L1 message\".\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    pub unconstrained fn call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Makes a read-only call to a public function on another contract.\n    pub unconstrained fn static_call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Adds a new note hash to the Note Hash Tree.\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_note_hash(note_hash) };\n    }\n\n    /// Adds a new nullifier to the Nullifier Tree.\n    pub fn push_nullifier(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { avm::sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n\n    /// Returns the \"transaction fee\" for the current transaction.\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::chain_id()\n        }\n    }\n\n    /// Returns the protocol version.\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::version()\n        }\n    }\n\n    /// Returns the current block number.\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas.\n    pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA gas.\n    pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available.\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA gas available.\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context.\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::is_static_call() }\n    }\n\n    /// Reads raw field values from public storage.\n    pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe {\n                avm::storage_read(storage_slot + i as Field, self.this_address().to_field())\n            };\n        }\n        out\n    }\n\n    /// Reads a typed value from public storage.\n    pub fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    /// Writes raw field values to public storage.\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n"
     },
-    "61": {
+    "60": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -2404,7 +2186,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/hash.nr",
       "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE,\n        DOM_SEP__PUBLIC_CALLDATA, DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__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], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the separator.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n"
     },
-    "70": {
+    "69": {
       "function_locations": [
         {
           "name": "compute_nullifier_existence_request",
@@ -2414,7 +2196,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/nullifier/utils.nr",
       "source": "use crate::{context::NullifierExistenceRequest, oracle::nullifiers::is_nullifier_pending};\n\nuse crate::protocol::{address::aztec_address::AztecAddress, hash::compute_siloed_nullifier};\n\n/// Returns the [NullifierExistenceRequest] used to prove a nullifier exists.\npub fn compute_nullifier_existence_request(\n    unsiloed_nullifier: Field,\n    contract_address: AztecAddress,\n) -> NullifierExistenceRequest {\n    let pending_read_request =\n        NullifierExistenceRequest::for_pending(unsiloed_nullifier, contract_address);\n\n    let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n    let settled_read_request = NullifierExistenceRequest::for_settled(siloed_nullifier);\n\n    // Safety: This is a hint to check whether we are reading a pending or settled nullifier. The chosen read request\n    // will be validated by the kernel. Failure to provide a correct hint will cause the read request validation to\n    // fail.\n    let should_use_pending_read_request =\n        unsafe { is_nullifier_pending(unsiloed_nullifier, contract_address) };\n\n    if should_use_pending_read_request {\n        pending_read_request\n    } else {\n        settled_read_request\n    }\n}\n"
     },
-    "71": {
+    "70": {
       "function_locations": [
         {
           "name": "address",
@@ -2652,7 +2434,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
       "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "79": {
+    "78": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -2682,15 +2464,15 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns true if the nullifier has been emitted in the same transaction, i.e. if [notify_created_nullifier] has been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(\n    inner_nullifier: Field,\n    contract_address: AztecAddress,\n) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(\n    _inner_nullifier: Field,\n    _contract_address: AztecAddress,\n) -> bool {}\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\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns 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)\n}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_utl_doesNullifierExist)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n"
     },
-    "83": {
+    "82": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
-          "start": 1191
+          "start": 1192
         },
         {
           "name": "assert_compatible_oracle_version_wrapper",
-          "start": 1500
+          "start": 1501
         },
         {
           "name": "assert_compatible_oracle_version_oracle",
@@ -2706,7 +2488,7 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_utl_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 22;\npub global ORACLE_VERSION_MINOR: Field = 1;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_utl_assertCompatibleOracleVersionV2)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{\n        assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR,\n    };\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
+      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 29;\npub global ORACLE_VERSION_MINOR: Field = 0;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{\n        assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR,\n    };\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
     },
     "84": {
       "function_locations": [
@@ -2859,7 +2641,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rVhbbuM4ELyLvv3BfvGRqwwGgZMoAwOGE3jsBRaB777dtpqyByB3lrM/VrlklYrNYlPW1/Q2v5x/PO8O7x8/p6dvX9PLcbff73487z9et6fdx0HZrynYR9RP2kxRpifeTCncDvl6yDQ9RT3oN9DflHQ7QsAFIDnwU+SnyBl2hp0RcCALMBM3wA7KApLfIi0uIJugGIgLKOBgYTCAA2fAGTAbOipEdOAM2W+ygbgAdoadEWekLMA8IxpQBo1JylBQYFbJTuW0gGIMGTBGa0zEDvRyUofE7MAYNUZiTDJgjN6C7KY34Mz1psVAWUBWhoOBsoDiTLEJhs3EQcvLaMAYNcYsCxDLAhuQBdg0sRgwRo3xNS/JgCwgO5ONUWNcggNj1JiE4ED9SDCgDkX9CBiDBoxRG4LswBi1IVaxG3CGnbGKiToUq9gNOBOdsYqJmhermOTLZTP5sng+HefZVsXdOtHV87k9zofT9HQ47/eb6a/t/nz90c/P7eF6PG2PelbHMR/e9KiC77v9bOiyWa8O7UsB2YZ4vVxxkiohjxrQ1igRYJEokXBVyA8K2HERcnQTEEpVSDA6jtQaR1cjhlUjQmxpSFuDLF1XBV0oQ+PQcKweArY8pH4tqkRZZzTLg0JuK2D2SOl6rdcj4INA6USCglsoxOsgIJXHVHVKUQL7bJRQQlsDetPhEpTvBkK/KHSiqV3bo4mQeUwDyW0gxo4PbmswJJ8TxrDGG/Jv26CSoE5rKk0bvWhB8XwDhdiKFnQkEqJLJN3cVgkeXCPU7lmdhOqGz14NxZFaRrDjJOvGtGhkTrHZ+ToJjbWgCVKrYfzLQJKsAympORDqiGQM2UWyxrUpwr0ujlTbeNBJataj00BLKalqBOCmRuzUVJ/dFo0IuW2jk1JMXg4szT7eH4c9TPg4MDdNdKaWROqCvd8KfrXRn9hYfWTtyq2JpU5G9dlRajUo33Vi+A8adamQzuughtTdNYAMaWgJak1DhEGNuuIIgEY1uGpgGtMASVUjxlGNWDUS/A8aoz5K1UAc9VHCn2vkmjEkHtPQh8eqMVpTzDVjBKM+cs0Y4di6JVozRqMZozUfNFqPB41RH2vG9CFqVCP8ucaaMabB/sFrL+RYxjQS+96gJcUxjXz3X2Gwr+ufDM8YB2j3wt9/DBKA1kYnvV0/1D+AGPjeiGp816/b193x4VXWxcSOu+3Lfl6+vp8Pr3dnT39/+hl/FfZ5/Hid387H2ZTW92H2nugb6L8Z3VK+X+x+/wA=",
+      "debug_symbols": "rVjbbts6EPwXPfuBe+Mlv1IUgZM4hQHDCdzkAAdB/r27MZeyC5BN2L5Y45E1Gi6HS1lvy8Pu7vXH7f74+PRzufn2ttyd9ofD/sft4el++7J/Oir7tgT7iPpJmyXKcsObJYXzIX8cMi03UQ/6DfQ3JZ2PELACJAd+ivwUOcPOsDMCDqQCM3EG7KBUkPwWqbqAbIJiIFZQwEFlMIADZ8AZMBs6KkR04AzZb7KBWAEbUwzECsQZKRWYZyQDyqAxSRkCBWaV7FROFRRj2IAx6oeIHejlpDaI2YExSYEYkw0Yo7cgu+kZOGM35WCgVJCNAQOlguJMsQnGzcJBy8tkwBg1xiwViGVBDEgFNk0cDRijxvgjL9mAVJCdycaoMS7BgTKixiQEB+pHwIA6FPUjYAwZMEZtCLIDY9SGWMXOwBl2xiom6lCsYmfgTHTGKiZqXqxiUt7fN4svi9uX025nq+Jinejqed6edseX5eb4ejhslv+2h9ePH/183h4/ji/bk57VAe2OD3pUwcf9YWfofbNeHfqXgsYh1ssVl9wkuFxpQF+jRIAqUSJhU5B0pYADFyE3ExBKU0hfGUcsLkEhht44RhoE2GwQUOlpSF+D2F3oQpkZB4WSVg8oPQ9pVAtbMz6lq0KWK4XcV8DskaKLRCDglUAZRIKCWyjEayQg/ZaqQSlKsPZw1ggl9DVgNB0uQfliIPSbwiCa2rU9EwiZ5zSQ3AZiHPjgvgZD8jlhDOmiGp+2QSVBm9ZUujZG0YJyucp60YKBREJ0iaSb2yrBX5FAlyCAnsTnl5l02x6ORCKzF1RxpJ4RHCQ0695WNTKn2G2eg3mNbU4SpF7P+cNAkqwDKak7kEFA9ekoZBfJmviuiIw2AqTWggNK6tYjDhpHWec2BOCuxiBiUR//qkaE3LcxaqLJy4GluxWMxyG4jgNzzwQNppZE2pqPAbs2xhMbm4+sjb03sTRqgQWlVYPyRfuCL2i0pUI6r5Ma0jboADKloSVoNQ0RJjXaitMORrMa3DQwzWmApKYR46xGbBoJ/oHGrI/SNBBnfZTw9xq5ZQyJ5zQwtozhbE0xt4wRzPrILWOEc+uWaM0YzWaM1nzQbD2uNGZ9rBnT57BZjfD3GmvGmCb7B6+9kGOZ00jse4OWFOc08sXfjcm+rv9TPGMcoN8LP/8YJP0HSxnt+iG0Z/3Al0ZU47t+3d7vT1dvw95N7LTf3h129evj6/H+4uzL/89+xt+mPZ+e7ncPr6edKa2v1OxV0zfQP0S6pXx/t/v9Ag==",
       "is_unconstrained": true,
       "name": "get_update_delay"
     },
@@ -2919,11 +2701,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "public_dispatch"
     },
@@ -2942,25 +2724,9 @@
             "error_kind": "string",
             "string": "attempt to add with overflow"
           },
-          "1560923443647584783": {
-            "error_kind": "string",
-            "string": "TpkM is the point at infinity"
-          },
-          "1911279422186654533": {
-            "error_kind": "string",
-            "string": "OvpkM is the point at infinity"
-          },
-          "4135474769840782447": {
-            "error_kind": "string",
-            "string": "Point at infinity should have canonical representation (0 0)"
-          },
           "718532354304118388": {
             "error_kind": "string",
             "string": "Point not on curve"
-          },
-          "7264753475633835214": {
-            "error_kind": "string",
-            "string": "NpkM is the point at infinity"
           }
         },
         "parameters": [
@@ -3453,119 +3219,24 @@
             "visibility": "private"
           },
           {
-            "name": "public_keys",
+            "name": "immutables_hash",
             "type": {
-              "fields": [
-                {
-                  "name": "npk_m",
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "inner",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "x",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "y",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "is_infinite",
-                              "type": {
-                                "kind": "boolean"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "aztec::protocol_types::point::Point"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "aztec::protocol_types::public_keys::NpkM"
-                  }
-                },
-                {
-                  "name": "ivpk_m",
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "inner",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "x",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "y",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "is_infinite",
-                              "type": {
-                                "kind": "boolean"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "aztec::protocol_types::point::Point"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "aztec::protocol_types::public_keys::IvpkM"
-                  }
-                },
-                {
-                  "name": "ovpk_m",
-                  "type": {
-                    "fields": [
-                      {
-                        "name": "inner",
-                        "type": {
-                          "fields": [
-                            {
-                              "name": "x",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "y",
-                              "type": {
-                                "kind": "field"
-                              }
-                            },
-                            {
-                              "name": "is_infinite",
-                              "type": {
-                                "kind": "boolean"
-                              }
-                            }
-                          ],
-                          "kind": "struct",
-                          "path": "aztec::protocol_types::point::Point"
-                        }
-                      }
-                    ],
-                    "kind": "struct",
-                    "path": "aztec::protocol_types::public_keys::OvpkM"
+              "kind": "field"
+            },
+            "visibility": "private"
+          },
+          {
+            "name": "public_keys",
+            "type": {
+              "fields": [
+                {
+                  "name": "npk_m_hash",
+                  "type": {
+                    "kind": "field"
                   }
                 },
                 {
-                  "name": "tpk_m",
+                  "name": "ivpk_m",
                   "type": {
                     "fields": [
                       {
@@ -3583,21 +3254,39 @@
                               "type": {
                                 "kind": "field"
                               }
-                            },
-                            {
-                              "name": "is_infinite",
-                              "type": {
-                                "kind": "boolean"
-                              }
                             }
                           ],
                           "kind": "struct",
-                          "path": "aztec::protocol_types::point::Point"
+                          "path": "std::embedded_curve_ops::EmbeddedCurvePoint"
                         }
                       }
                     ],
                     "kind": "struct",
-                    "path": "aztec::protocol_types::public_keys::TpkM"
+                    "path": "aztec::protocol_types::public_keys::IvpkM"
+                  }
+                },
+                {
+                  "name": "ovpk_m_hash",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "tpk_m_hash",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "mspk_m_hash",
+                  "type": {
+                    "kind": "field"
+                  }
+                },
+                {
+                  "name": "fbpk_m_hash",
+                  "type": {
+                    "kind": "field"
                   }
                 }
               ],
@@ -4275,30 +3964,9 @@
                               "type": {
                                 "fields": [
                                   {
-                                    "name": "pk_m",
+                                    "name": "pk_m_hash",
                                     "type": {
-                                      "fields": [
-                                        {
-                                          "name": "x",
-                                          "type": {
-                                            "kind": "field"
-                                          }
-                                        },
-                                        {
-                                          "name": "y",
-                                          "type": {
-                                            "kind": "field"
-                                          }
-                                        },
-                                        {
-                                          "name": "is_infinite",
-                                          "type": {
-                                            "kind": "boolean"
-                                          }
-                                        }
-                                      ],
-                                      "kind": "struct",
-                                      "path": "aztec::protocol_types::point::Point"
+                                      "kind": "field"
                                     }
                                   },
                                   {
@@ -4918,14 +4586,14 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "tVtRbhs5DL2Lv/MhkiIl5iqLRZG23iJAkBZpssCiyN2XciTN2IVYZcb56dPE1jNHeqQoSv11+Hr8/PLt0/3jP99/Hm7/+nX4/HT/8HD/7dPD9y93z/ffH+2vvw6h/APxcAvwenOA0xPZU7AnbE/x5vSVAny4ZQM53IpBMrAvUvtievtI7W/x9DcjRHvg8pDsE7g5pPQG+Q3U4NW+0qz69Px0PJavr8w043/cPR0fnw+3jy8PDzeHf+8eXk5f+vnj7vGEz3dP9mm4ORwfvxoa4T/3D8fSer1ZeodxV0SOtTdi1k4AGWYpdvx6xvbjOeblt/msP437i0jtL4k39E+Bav8EYVN/bP1x+PvO+ytw7a8IW/pzbv2TjvrncX+AkNoMWFvTwiGzNkBUaBTM1BlSnmbgkDqDLvOQcZaBEZoNjHGZiahnDICOEZTbWEKkTUZw6kawytCI6HhjbnpGXeYTQadtEGrzySI4tEEcG0Byjwi4KELOvRqSI0sKXdcUFysgXZjhSFNDbL6pYSWK3zh0zEGdwiZ3GU46Z0BnPClAkyaFlYu/iwNCC5EE5HA46oyQGkfEsHLT9I5XQe2vwrLtVSQ2gZJw3MjRgxaJbJwW6f5OgrSNQ6G5CmnUMUf+2GnRHjVoHcQvzfCcPoU2K5xiHDk9gWMFcvNYQl2WIpZ5iihtMSRexWCeXklYe/CSkIYBlKIXg5vHCywmyAUBezb00CUBZRh2SPaHP0r7wx/lveGPdH/4czkmw1+E3X7mmjEZunyOubDjKRQCtFmx5AtGGnXcRELPEsyeNHKTKK4RuSdtATSPvDUmL20T6cmjtbe4vJC2RUniakQv38WZlBh7HI9RZGQEO1ZEXNSFSwjmTW9Bw6yL0fP3nsmvLIjTOymJqXmqzcpwDWBXmch9LwCrsMXnW0F2wmeKsEStFQOdM1whePIVgifvDp58heDJVwiesj948hWCp88xl/fxFQKwyzGZ94l87JBO5n2ex+rKYVejcemwot62N4YewwMMOVLY77IJ9rtswr0um2i/y7ocky6beLe+XDMmXdbnmHM3b13KuefT5nijdSk5ErVSSH+TsFpdy8Cc1bncze9qTpbh1HMrMsw5CvHKUeI7KFg6haRtFKQLRR5SeENBfTQjjIciTPnZumq7jYFxN0PaxoB9HHIYMnjS1s4gyjqStrpzEXpNhnQsbdeKvhuwavZwN6DobSgY+573TFTnJVx1QgVG7FXDuMo/L99EvQQUoJdgYVVB+I3DS0BTo8gCY4YrJKB6hQRUdyegeoUEVK+QgNoucvdyplfIQPUK2aOrc+o1KhQeaxQCX6E+HuQKBfKQ9ooMQt6vMp9kVmYQdsvsD28zVyX3SSbF+geSuf3SH0jmJO+TTO6YAOSDJ2dyz+QvdkutBtfJx8ViB97B0rQDe5X/aQdG2O3A3tnStAO7JLMOjHG/RlxDZn3PJ5lcKTyhxb47N5N0LDR042Iv6xGuTjQu8n1Ab4uv/VAENA2vObgcGLCliBji8KoDeAdEnJazmZUV8h4rlqPpoDC2gj7UCsjaD8iDbBtPyLSfo3sLnnnLezioCx2Jx9rwjpmAtJeh4np3/R6O2NMqiPEaHGkjB/dzkfVhwjs5eqUgZtj/Lls5OCwXcyDs56CtHHHhkDjk8M6a5rzWt6J7HIjjcd5R05QV/prQbzrZgU0Yrwns7aZir0SZzIeVqD9w9HgeY6YxB7mnZqmv1qz7OQRHHPNjGp0xFVcdvTQnkMbv4mkUehxkjHk/x7jK6GSVCakNR8JxVcp8wMlMWXpmyuPDYfBOnbhfpxNavO3iUqBvheSmc5XV1cTfrKCPPaNOSfstz4xhPKLOjr/UCnrZIA2rdJ4VmRYr1LHCO7GX1KvHaa3yi8u+pxuA4ySsTwvCajjecWM4Y19lM6bxdU3v0MmKhaLLcXUeHvyDd+x0DX3kpSSU1wXx8jZ/29Pdl/un89vn5bJ4uQVSLpJjwVxR3xBDRaiIFalirMgVpWLlw8qHlY8qH1U+Knw2eEQVY9leGHJFKfVow1Qxl/BsqG8YQ0WoaHzR9B2povFFk1DkilIim2GqmN+QjaesDgxlM26IFaliLBe7DbmiVDSeZPGac0UtQro5SKgIFbFMiSFVjBWNLxuPGF/J5SVVzBX1DVMoV7QNoRQmjDBha9BJddaIrcGtIa2RWiO3htZGDqVhFmRojcJcNoyZWqMwk+kuF+YS1PNJNmZXTq2RT+ucNbQ2NJySNmtAa+ApBbMGndY5axTmMr5amIv+VVqjMBe/0sJcDltVT43Xov+n+7vPD8ci4SLyl8cvTdH2+Pzfj/ZJ+x8XP56+fzl+fXk6FvWfhH/6DxFmxl8WKxP//Voc5H8=",
       "is_unconstrained": false,
       "name": "publish_for_public_execution",
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "abi": {
@@ -4972,7 +4640,7 @@
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "set_update_delay"
     },
@@ -5024,17 +4692,17 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "update"
     }
   ],
   "name": "ContractInstanceRegistry",
-  "noir_version": "1.0.0-beta.20+ad02a20cd80b3e8a6189722b11a625998e578435",
+  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
   "outputs": {
     "globals": {},
     "structs": {
@@ -5097,44 +4765,20 @@
                 "kind": "field"
               }
             },
+            {
+              "name": "immutables_hash",
+              "type": {
+                "kind": "field"
+              }
+            },
             {
               "name": "public_keys",
               "type": {
                 "fields": [
                   {
-                    "name": "npk_m",
+                    "name": "npk_m_hash",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "x",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "y",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "is_infinite",
-                                "type": {
-                                  "kind": "boolean"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::point::Point"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::public_keys::NpkM"
+                      "kind": "field"
                     }
                   },
                   {
@@ -5156,16 +4800,10 @@
                                 "type": {
                                   "kind": "field"
                                 }
-                              },
-                              {
-                                "name": "is_infinite",
-                                "type": {
-                                  "kind": "boolean"
-                                }
                               }
                             ],
                             "kind": "struct",
-                            "path": "aztec::protocol_types::point::Point"
+                            "path": "std::embedded_curve_ops::EmbeddedCurvePoint"
                           }
                         }
                       ],
@@ -5174,75 +4812,27 @@
                     }
                   },
                   {
-                    "name": "ovpk_m",
+                    "name": "ovpk_m_hash",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "x",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "y",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "is_infinite",
-                                "type": {
-                                  "kind": "boolean"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::point::Point"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::public_keys::OvpkM"
+                      "kind": "field"
                     }
                   },
                   {
-                    "name": "tpk_m",
+                    "name": "tpk_m_hash",
                     "type": {
-                      "fields": [
-                        {
-                          "name": "inner",
-                          "type": {
-                            "fields": [
-                              {
-                                "name": "x",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "y",
-                                "type": {
-                                  "kind": "field"
-                                }
-                              },
-                              {
-                                "name": "is_infinite",
-                                "type": {
-                                  "kind": "boolean"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::point::Point"
-                          }
-                        }
-                      ],
-                      "kind": "struct",
-                      "path": "aztec::protocol_types::public_keys::TpkM"
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "mspk_m_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
+                  {
+                    "name": "fbpk_m_hash",
+                    "type": {
+                      "kind": "field"
                     }
                   }
                 ],
@@ -5391,44 +4981,20 @@
                       "kind": "field"
                     }
                   },
+                  {
+                    "name": "_immutables_hash",
+                    "type": {
+                      "kind": "field"
+                    }
+                  },
                   {
                     "name": "_public_keys",
                     "type": {
                       "fields": [
                         {
-                          "name": "npk_m",
+                          "name": "npk_m_hash",
                           "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "fields": [
-                                    {
-                                      "name": "x",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "y",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "is_infinite",
-                                      "type": {
-                                        "kind": "boolean"
-                                      }
-                                    }
-                                  ],
-                                  "kind": "struct",
-                                  "path": "aztec::protocol_types::point::Point"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::public_keys::NpkM"
+                            "kind": "field"
                           }
                         },
                         {
@@ -5450,16 +5016,10 @@
                                       "type": {
                                         "kind": "field"
                                       }
-                                    },
-                                    {
-                                      "name": "is_infinite",
-                                      "type": {
-                                        "kind": "boolean"
-                                      }
                                     }
                                   ],
                                   "kind": "struct",
-                                  "path": "aztec::protocol_types::point::Point"
+                                  "path": "std::embedded_curve_ops::EmbeddedCurvePoint"
                                 }
                               }
                             ],
@@ -5468,75 +5028,27 @@
                           }
                         },
                         {
-                          "name": "ovpk_m",
+                          "name": "ovpk_m_hash",
                           "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "fields": [
-                                    {
-                                      "name": "x",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "y",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "is_infinite",
-                                      "type": {
-                                        "kind": "boolean"
-                                      }
-                                    }
-                                  ],
-                                  "kind": "struct",
-                                  "path": "aztec::protocol_types::point::Point"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::public_keys::OvpkM"
+                            "kind": "field"
                           }
                         },
                         {
-                          "name": "tpk_m",
+                          "name": "tpk_m_hash",
                           "type": {
-                            "fields": [
-                              {
-                                "name": "inner",
-                                "type": {
-                                  "fields": [
-                                    {
-                                      "name": "x",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "y",
-                                      "type": {
-                                        "kind": "field"
-                                      }
-                                    },
-                                    {
-                                      "name": "is_infinite",
-                                      "type": {
-                                        "kind": "boolean"
-                                      }
-                                    }
-                                  ],
-                                  "kind": "struct",
-                                  "path": "aztec::protocol_types::point::Point"
-                                }
-                              }
-                            ],
-                            "kind": "struct",
-                            "path": "aztec::protocol_types::public_keys::TpkM"
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "mspk_m_hash",
+                          "type": {
+                            "kind": "field"
+                          }
+                        },
+                        {
+                          "name": "fbpk_m_hash",
+                          "type": {
+                            "kind": "field"
                           }
                         }
                       ],
@@ -5615,5 +5127,6 @@
       ]
     }
   },
-  "transpiled": true
+  "transpiled": true,
+  "aztec_version": "0.0.1-commit.b3d3157a"
 }