@aztec/protocol-contracts 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/artifacts/ContractInstanceRegistry.json

@@ -264,7 +264,7 @@
       "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    /// 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\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::default::Default;\n    use crate::embedded_curve_ops::{\n        embedded_curve_add, EmbeddedCurvePoint, EmbeddedCurveScalar, fixed_base_scalar_mul,\n        multi_scalar_mul,\n    };\n    use crate::field::bn254::TWO_POW_128;\n    use crate::hash::Hash;\n    use crate::hash::Hasher;\n    use crate::hash::poseidon2::Poseidon2Hasher;\n\n    fn hash_point(p: EmbeddedCurvePoint) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        p.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    fn hash_scalar(s: EmbeddedCurveScalar) -> Field {\n        let mut hasher: Poseidon2Hasher = Default::default();\n        s.hash(&mut hasher);\n        hasher.finish()\n    }\n\n    #[test]\n    fn point_new_sets_coordinates() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(p.x, 3);\n        assert_eq(p.y, 5);\n    }\n\n    #[test]\n    fn point_at_infinity_is_origin() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(inf.x, 0);\n        assert_eq(inf.y, 0);\n    }\n\n    #[test]\n    fn generator_has_documented_coordinates() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.x, 1);\n        assert_eq(g.y, 17631683881184975370165255887551781615748388533673675138860);\n    }\n\n    #[test]\n    fn is_infinite_only_true_for_origin() {\n        assert(EmbeddedCurvePoint::point_at_infinity().is_infinite());\n        assert(!EmbeddedCurvePoint::generator().is_infinite());\n        assert(!EmbeddedCurvePoint::new(1, 0).is_infinite());\n        assert(!EmbeddedCurvePoint::new(0, 1).is_infinite());\n    }\n\n    #[test]\n    fn points_with_same_coords_are_equal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        let q = EmbeddedCurvePoint::new(7, 11);\n        assert_eq(p, q);\n    }\n\n    #[test]\n    fn points_with_different_coords_are_unequal() {\n        let p = EmbeddedCurvePoint::new(7, 11);\n        assert(p != EmbeddedCurvePoint::new(7, 12));\n        assert(p != EmbeddedCurvePoint::new(8, 11));\n        assert(p != EmbeddedCurvePoint::new(8, 12));\n    }\n\n    #[test]\n    fn neg_negates_y_coordinate() {\n        let g = EmbeddedCurvePoint::generator();\n        let neg_g = -g;\n        assert_eq(neg_g.x, g.x);\n        assert_eq(neg_g.y, -g.y);\n    }\n\n    #[test]\n    fn neg_is_involution() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(--g, g);\n    }\n\n    #[test]\n    fn add_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g + inf, g);\n        assert_eq(inf + g, g);\n    }\n\n    #[test]\n    fn add_of_two_infinities_is_infinity() {\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert((inf + inf).is_infinite());\n    }\n\n    #[test]\n    fn add_with_negation_is_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g + (-g)).is_infinite());\n    }\n\n    #[test]\n    fn add_is_commutative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(g + g2, g2 + g);\n    }\n\n    #[test]\n    fn add_is_associative() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        let g3 = g + g2;\n        assert_eq((g + g2) + g3, g + (g2 + g3));\n    }\n\n    #[test]\n    fn sub_of_a_point_with_itself_is_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        assert((g - g).is_infinite());\n    }\n\n    #[test]\n    fn sub_with_point_at_infinity_is_identity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        assert_eq(g - inf, g);\n    }\n\n    #[test]\n    fn sub_inverts_add() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq((g + g2) - g2, g);\n        assert_eq((g + g2) - g, g2);\n    }\n\n    #[test]\n    fn double_equals_self_plus_self() {\n        let g = EmbeddedCurvePoint::generator();\n        assert_eq(g.double(), g + g);\n    }\n\n    #[test]\n    fn double_of_point_at_infinity_is_infinity() {\n        assert(EmbeddedCurvePoint::point_at_infinity().double().is_infinite());\n    }\n\n    #[test]\n    fn embedded_curve_add_matches_add_operator() {\n        let g = EmbeddedCurvePoint::generator();\n        let g2 = g.double();\n        assert_eq(embedded_curve_add(g, g2), g + g2);\n    }\n\n    #[test]\n    fn point_hash_is_consistent_for_equal_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        let q = EmbeddedCurvePoint::new(3, 5);\n        assert_eq(hash_point(p), hash_point(q));\n    }\n\n    #[test]\n    fn point_hash_differs_for_distinct_points() {\n        let p = EmbeddedCurvePoint::new(3, 5);\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(3, 7)));\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(4, 5)));\n        // Distinguishes (x, y) from (y, x) - order of writes matters.\n        assert(hash_point(p) != hash_point(EmbeddedCurvePoint::new(5, 3)));\n    }\n\n    #[test]\n    fn scalar_new_sets_limbs() {\n        let s = EmbeddedCurveScalar::new(3, 5);\n        assert_eq(s.lo, 3);\n        assert_eq(s.hi, 5);\n    }\n\n    #[test]\n    fn scalars_with_same_limbs_are_equal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(s, t);\n    }\n\n    #[test]\n    fn scalars_with_different_limbs_are_unequal() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(s != EmbeddedCurveScalar::new(7, 12));\n        assert(s != EmbeddedCurveScalar::new(8, 11));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_zero() {\n        assert_eq(EmbeddedCurveScalar::from_field(0), EmbeddedCurveScalar::new(0, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_small_value() {\n        let s = EmbeddedCurveScalar::from_field(0x1234567890);\n        assert_eq(s, EmbeddedCurveScalar::new(0x1234567890, 0));\n    }\n\n    #[test]\n    fn scalar_from_field_decomposes_two_pow_128() {\n        let s = EmbeddedCurveScalar::from_field(TWO_POW_128);\n        assert_eq(s, EmbeddedCurveScalar::new(0, 1));\n    }\n\n    #[test]\n    fn scalar_hash_is_consistent_for_equal_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        let t = EmbeddedCurveScalar::new(7, 11);\n        assert_eq(hash_scalar(s), hash_scalar(t));\n    }\n\n    #[test]\n    fn scalar_hash_differs_for_distinct_scalars() {\n        let s = EmbeddedCurveScalar::new(7, 11);\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(7, 12)));\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(8, 11)));\n        // Distinguishes (lo, hi) from (hi, lo) - limb order matters.\n        assert(hash_scalar(s) != hash_scalar(EmbeddedCurveScalar::new(11, 7)));\n    }\n\n    #[test]\n    fn msm_with_scalar_one_returns_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g], [one]), g);\n    }\n\n    #[test]\n    fn msm_with_scalar_zero_returns_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(multi_scalar_mul([g], [zero]).is_infinite());\n    }\n\n    #[test]\n    fn msm_with_scalar_two_doubles_point() {\n        let g = EmbeddedCurvePoint::generator();\n        let two = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(multi_scalar_mul([g], [two]), g.double());\n    }\n\n    #[test]\n    fn msm_sums_terms() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([g, g], [one, one]), g.double());\n    }\n\n    #[test]\n    fn msm_with_opposite_terms_cancels() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert(multi_scalar_mul([g, -g], [one, one]).is_infinite());\n    }\n\n    #[test]\n    fn msm_skips_point_at_infinity() {\n        let g = EmbeddedCurvePoint::generator();\n        let inf = EmbeddedCurvePoint::point_at_infinity();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(multi_scalar_mul([inf, g], [one, one]), g);\n    }\n\n    #[test]\n    fn msm_skips_zero_scalar() {\n        let g = EmbeddedCurvePoint::generator();\n        let one = EmbeddedCurveScalar::new(1, 0);\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert_eq(multi_scalar_mul([g, g], [zero, one]), g);\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_one_returns_generator() {\n        let one = EmbeddedCurveScalar::new(1, 0);\n        assert_eq(fixed_base_scalar_mul(one), EmbeddedCurvePoint::generator());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_with_zero_returns_infinity() {\n        let zero = EmbeddedCurveScalar::new(0, 0);\n        assert(fixed_base_scalar_mul(zero).is_infinite());\n    }\n\n    #[test]\n    fn fixed_base_scalar_mul_matches_msm_on_generator() {\n        let s = EmbeddedCurveScalar::new(2, 0);\n        assert_eq(\n            fixed_base_scalar_mul(s),\n            multi_scalar_mul([EmbeddedCurvePoint::generator()], [s]),\n        );\n    }\n}\n"
     },
-    "147": {
+    "148": {
       "function_locations": [
         {
           "name": "<impl Empty for AztecAddress>::empty",
@@ -351,7 +351,7 @@
           "start": 12908
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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]\nfn 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": {
@@ -424,7 +424,7 @@
       "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    use crate::internal::test_unconstrained;\n    use super::assert_lt;\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    #[test_unconstrained]\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(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"
     },
-    "150": {
+    "151": {
       "function_locations": [
         {
           "name": "<impl ToField for PartialAddress>::to_field",
@@ -463,10 +463,10 @@
           "start": 1884
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "152": {
+    "153": {
       "function_locations": [
         {
           "name": "<impl ToField for SaltedInitializationHash>::to_field",
@@ -485,7 +485,7 @@
           "start": 950
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/salted_initialization_hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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": {
@@ -658,97 +658,109 @@
           "name": "tests::non_zero_field_to_be_bytes_zero_limbs",
           "start": 19469
         },
+        {
+          "name": "tests::zero_field_to_bytes_zero_limbs_unconstrained",
+          "start": 19600
+        },
+        {
+          "name": "tests::zero_field_to_bytes_zero_limbs_constrained",
+          "start": 19915
+        },
+        {
+          "name": "tests::zero_field_to_bytes_zero_limbs_comptime",
+          "start": 20227
+        },
         {
           "name": "tests::test_field_less_than",
-          "start": 19576
+          "start": 20558
         },
         {
           "name": "tests::test_large_field_values_unconstrained",
-          "start": 19831
+          "start": 20813
         },
         {
           "name": "tests::test_large_field_values",
-          "start": 20284
+          "start": 21266
         },
         {
           "name": "tests::test_decomposition_edge_cases",
-          "start": 20731
+          "start": 21713
         },
         {
           "name": "tests::test_pow_32",
-          "start": 21321
+          "start": 22303
         },
         {
           "name": "tests::test_sgn0",
-          "start": 21650
+          "start": 22632
         },
         {
           "name": "tests::test_bit_decomposition_overflow",
-          "start": 22072
+          "start": 23054
         },
         {
           "name": "tests::test_byte_decomposition_overflow",
-          "start": 22354
+          "start": 23336
         },
         {
           "name": "tests::test_to_from_be_bytes_bn254_edge_cases",
-          "start": 22571
+          "start": 23553
         },
         {
           "name": "tests::test_to_from_le_bytes_bn254_edge_cases",
-          "start": 24522
+          "start": 25504
         },
         {
           "name": "tests::test_from_le_bytes_checked_accepts_modulus_minus_one",
-          "start": 26457
+          "start": 27439
         },
         {
           "name": "tests::test_from_le_bytes_checked_rejects_modulus",
-          "start": 26936
+          "start": 27918
         },
         {
           "name": "tests::test_from_le_bytes_checked_rejects_modulus_plus_one",
-          "start": 27321
+          "start": 28303
         },
         {
           "name": "tests::test_from_be_bytes_checked_accepts_modulus_minus_one",
-          "start": 27776
+          "start": 28758
         },
         {
           "name": "tests::test_from_be_bytes_checked_rejects_modulus",
-          "start": 28265
+          "start": 29247
         },
         {
           "name": "tests::test_from_be_bytes_checked_rejects_modulus_plus_one",
-          "start": 28650
+          "start": 29632
         },
         {
           "name": "tests::test_from_bytes_checked_small_n",
-          "start": 29094
+          "start": 30076
         },
         {
           "name": "tests::from_le_bits",
-          "start": 29739
+          "start": 30721
         },
         {
           "name": "tests::from_be_bits",
-          "start": 30286
+          "start": 31268
         },
         {
           "name": "tests::test_to_from_be_bits_bn254_edge_cases",
-          "start": 30532
+          "start": 31514
         },
         {
           "name": "tests::test_to_from_le_bits_bn254_edge_cases",
-          "start": 32465
+          "start": 33447
         },
         {
           "name": "tests::max_bit_size_too_large",
-          "start": 34397
+          "start": 35379
         }
       ],
       "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    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_le_bytes\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_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        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    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_be_bytes\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes\n        static_assert(\n            N <= modulus_be_bytes().len(),\n            \"N must be less than or equal to modulus_be_bytes().len()\",\n        );\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    /// Convert a little endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_le_bytes_checked\n    pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes_checked\n        let p = modulus_le_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[N - 1 - i] != p[N - 1 - i] {\n                    assert(\n                        bytes[N - 1 - i] < p[N - 1 - i],\n                        \"input bytes are not a canonical field representation\",\n                    );\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_le_bytes(bytes)\n    }\n\n    /// Convert a big endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_be_bytes_checked\n    pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes_checked\n        let p = modulus_be_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[i] != p[i] {\n                    assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_be_bytes(bytes)\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\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(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_be_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    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\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            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\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            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\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            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\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            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\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"
+      "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    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_le_bytes\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_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        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    ///\n    /// # Failures\n    /// `N` must be no greater than the number of bytes required to represent the field modulus\n    // docs:start:from_be_bytes\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes\n        static_assert(\n            N <= modulus_be_bytes().len(),\n            \"N must be less than or equal to modulus_be_bytes().len()\",\n        );\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    /// Convert a little endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_le_bytes_checked\n    pub fn from_le_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_le_bytes_checked\n        let p = modulus_le_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[N - 1 - i] != p[N - 1 - i] {\n                    assert(\n                        bytes[N - 1 - i] < p[N - 1 - i],\n                        \"input bytes are not a canonical field representation\",\n                    );\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_le_bytes(bytes)\n    }\n\n    /// Convert a big endian byte array to a field element, asserting that the input is a\n    /// canonical representation (strictly less than the field modulus).\n    ///\n    /// # Failures\n    /// Causes a constraint failure if `bytes` encodes a value greater than or equal to the\n    /// field modulus.\n    // docs:start:from_be_bytes_checked\n    pub fn from_be_bytes_checked<let N: u32>(bytes: [u8; N]) -> Field {\n        // docs:end:from_be_bytes_checked\n        let p = modulus_be_bytes();\n        let mut ok = N != p.len();\n        for i in 0..N {\n            if !ok {\n                if bytes[i] != p[i] {\n                    assert(bytes[i] < p[i], \"input bytes are not a canonical field representation\");\n                    ok = true;\n                }\n            }\n        }\n        assert(ok, \"input bytes are not a canonical field representation\");\n        Field::from_be_bytes(bytes)\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\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(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_le_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 0 limbs\")]\n    unconstrained fn non_zero_field_to_be_bytes_zero_limbs() {\n        let _: [u8; 0] = 5.to_be_bytes();\n    }\n\n    #[test]\n    unconstrained fn zero_field_to_bytes_zero_limbs_unconstrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_constrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_comptime() {\n        let _: [u8; 0] = comptime { (0 as Field).to_le_bytes() };\n        let _: [u8; 0] = comptime { (0 as Field).to_be_bytes() };\n        let _: [bool; 0] = comptime { (0 as Field).to_le_bits() };\n        let _: [bool; 0] = comptime { (0 as Field).to_be_bits() };\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    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\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            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\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            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\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            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\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            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\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"
     },
     "17": {
       "function_locations": [
@@ -760,183 +772,183 @@
           "name": "keccakf1600",
           "start": 707
         },
-        {
-          "name": "keccak::keccakf1600",
-          "start": 882
-        },
         {
           "name": "blake2s",
-          "start": 1044
+          "start": 852
         },
         {
           "name": "blake3",
-          "start": 1142
+          "start": 950
         },
         {
           "name": "__blake3",
-          "start": 1629
+          "start": 1437
         },
         {
           "name": "pedersen_commitment",
-          "start": 1747
+          "start": 1555
         },
         {
           "name": "pedersen_commitment_with_separator",
-          "start": 1976
+          "start": 1784
         },
         {
           "name": "pedersen_hash",
-          "start": 2380
+          "start": 2188
         },
         {
           "name": "pedersen_hash_with_separator",
-          "start": 2537
+          "start": 2345
         },
         {
           "name": "derive_generators",
-          "start": 3531
+          "start": 3339
         },
         {
           "name": "__derive_generators",
-          "start": 3890
+          "start": 3698
         },
         {
           "name": "poseidon2_permutation",
-          "start": 3968
+          "start": 3776
         },
         {
           "name": "poseidon2_permutation_internal",
-          "start": 4324
+          "start": 4132
         },
         {
           "name": "poseidon2_config_state_size",
-          "start": 4417
+          "start": 4225
         },
         {
           "name": "derive_hash",
-          "start": 4728
+          "start": 4536
+        },
+        {
+          "name": "Hasher::finish_ref",
+          "start": 5327
         },
         {
           "name": "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher",
-          "start": 5953
+          "start": 5761
         },
         {
           "name": "<impl Default for BuildHasherDefault<H>>::default",
-          "start": 6085
+          "start": 5893
         },
         {
           "name": "<impl Hash for Field>::hash",
-          "start": 6217
+          "start": 6025
         },
         {
           "name": "<impl Hash for u8>::hash",
-          "start": 6347
+          "start": 6155
         },
         {
           "name": "<impl Hash for u16>::hash",
-          "start": 6487
+          "start": 6295
         },
         {
           "name": "<impl Hash for u32>::hash",
-          "start": 6627
+          "start": 6435
         },
         {
           "name": "<impl Hash for u64>::hash",
-          "start": 6767
+          "start": 6575
         },
         {
           "name": "<impl Hash for u128>::hash",
-          "start": 6908
+          "start": 6716
         },
         {
           "name": "<impl Hash for i8>::hash",
-          "start": 7047
+          "start": 6855
         },
         {
           "name": "<impl Hash for i16>::hash",
-          "start": 7193
+          "start": 7001
         },
         {
           "name": "<impl Hash for i32>::hash",
-          "start": 7340
+          "start": 7148
         },
         {
           "name": "<impl Hash for i64>::hash",
-          "start": 7487
+          "start": 7295
         },
         {
           "name": "<impl Hash for bool>::hash",
-          "start": 7635
+          "start": 7443
         },
         {
           "name": "<impl Hash for ()>::hash",
-          "start": 7782
+          "start": 7590
         },
         {
           "name": "<impl Hash for [T; N]>::hash",
-          "start": 7914
+          "start": 7722
         },
         {
           "name": "<impl Hash for [T]>::hash",
-          "start": 8103
+          "start": 7911
         },
         {
           "name": "<impl Hash for (A,)>::hash",
-          "start": 8325
+          "start": 8133
         },
         {
           "name": "<impl Hash for (A, B)>::hash",
-          "start": 8494
+          "start": 8302
         },
         {
           "name": "<impl Hash for (A, B, C)>::hash",
-          "start": 8710
+          "start": 8518
         },
         {
           "name": "<impl Hash for (A, B, C, D)>::hash",
-          "start": 8973
+          "start": 8781
         },
         {
           "name": "<impl Hash for (A, B, C, D, E)>::hash",
-          "start": 9283
+          "start": 9091
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F)>::hash",
-          "start": 9640
+          "start": 9448
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G)>::hash",
-          "start": 10044
+          "start": 9852
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash",
-          "start": 10498
+          "start": 10306
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash",
-          "start": 10999
+          "start": 10807
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash",
-          "start": 11547
+          "start": 11355
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash",
-          "start": 12142
+          "start": 11950
         },
         {
           "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash",
-          "start": 12785
+          "start": 12593
         },
         {
           "name": "assert_pedersen",
-          "start": 13379
+          "start": 13187
         }
       ],
       "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> Hash for (A,)\nwhere\n    A: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\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\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: 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        self.5.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: 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        self.5.hash(state);\n        self.6.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n    L: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n        self.11.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"
+      "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\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> Hash for (A,)\nwhere\n    A: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\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\nimpl<A, B, C, D, E, F> Hash for (A, B, C, D, E, F)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: 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        self.5.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G> Hash for (A, B, C, D, E, F, G)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: 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        self.5.hash(state);\n        self.6.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_> Hash for (A, B, C, D, E, F, G, H_)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I> Hash for (A, B, C, D, E, F, G, H_, I)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J> Hash for (A, B, C, D, E, F, G, H_, I, J)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K> Hash for (A, B, C, D, E, F, G, H_, I, J, K)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E, F, G, H_, I, J, K, L> Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n    F: Hash,\n    G: Hash,\n    H_: Hash,\n    I: Hash,\n    J: Hash,\n    K: Hash,\n    L: 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        self.5.hash(state);\n        self.6.hash(state);\n        self.7.hash(state);\n        self.8.hash(state);\n        self.9.hash(state);\n        self.10.hash(state);\n        self.11.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"
     },
-    "170": {
+    "171": {
       "function_locations": [
         {
           "name": "DelayedPublicMutableValues<T, INITIAL_DELAY>::new",
@@ -963,10 +975,10 @@
           "start": 6756
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 |\n        //   sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n        // Note that this layout stores timestamps and delays in 32-bit slots. The 2106 timestamp overflow is accepted\n        // tech debt, but any value that exceeds its assigned slot would spill into adjacent fields and unpack to\n        // different data. Enforce the layout here so every persistence and hash path fails closed.\n        (self.svc.timestamp_of_change as Field).assert_max_bit_size::<32>();\n        (self.sdc.timestamp_of_change as Field).assert_max_bit_size::<32>();\n        (self.sdc.post.unwrap_unchecked() as Field).assert_max_bit_size::<32>();\n        (self.sdc.pre.unwrap_unchecked() as Field).assert_max_bit_size::<32>();\n\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"
     },
-    "173": {
+    "174": {
       "function_locations": [
         {
           "name": "ScheduledDelayChange<INITIAL_DELAY>::new",
@@ -997,10 +1009,10 @@
           "start": 23789
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_delay_change.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_delay_change.nr",
       "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to store the minimum delay with which a ScheduledValueChange\n// object can schedule a change.\n// This delay is initially equal to INITIAL_DELAY, and can be safely mutated to any other value over time. This mutation\n// is performed via `schedule_change` in order to satisfy ScheduleValueChange constraints: if e.g. we allowed for the\n// delay to be decreased immediately then it'd be possible for the state variable to schedule a value change with a\n// reduced delay, invalidating prior private reads.\npub struct ScheduledDelayChange<let INITIAL_DELAY: u64> {\n    // Both pre and post are stored in public storage, so by default they are zeroed. By wrapping them in an Option,\n    // they default to Option::none(), which we detect and replace with INITIAL_DELAY. The end result is that a\n    // ScheduledDelayChange that has not been initialized has a delay equal to INITIAL_DELAY, which is the desired\n    // effect. Once initialized, the Option will never be none again.\n    pub(crate) pre: Option<u64>,\n    pub(crate) post: Option<u64>,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<let INITIAL_DELAY: u64> ScheduledDelayChange<INITIAL_DELAY> {\n    pub fn new(pre: Option<u64>, post: Option<u64>, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the current value of the delay stored in the data structure.\n    /// WARNING: This function only returns a meaningful value when called in public with the current timestamp - for\n    /// historical private reads use `get_effective_minimum_delay_at` instead.\n    pub fn get_current(self, current_timestamp: u64) -> u64 {\n        // The post value becomes the current one at the timestamp of change, so any transaction that is included at or\n        // after the timestamp of change will use the post value.\n        if current_timestamp < self.timestamp_of_change {\n            self.pre.unwrap_or(INITIAL_DELAY)\n        } else {\n            self.post.unwrap_or(INITIAL_DELAY)\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change delay and the timestamp at which it will become the current\n    /// delay. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (u64, u64) {\n        (self.post.unwrap_or(INITIAL_DELAY), self.timestamp_of_change)\n    }\n\n    /// Schedules a change to the delay, given the `current_timestamp` and the `current` delay.\n    /// This function is only meaningful when called in public with the current timestamp.\n    /// The timestamp at which the new delay will become effective is determined automatically:\n    ///  - when increasing the delay, the change is effective immediately\n    ///  - when reducing the delay, the change will take effect after a delay equal to the difference between old and\n    ///    new delay. For example, if reducing from 3 days to 1 day, the reduction will be scheduled to happen after 2\n    ///    days.\n    pub fn schedule_change(&mut self, new: u64, current_timestamp: u64) {\n        let current = self.get_current(current_timestamp);\n\n        // When changing the delay value we must ensure that it is not possible to produce a value change with a delay\n        // shorter than the current one.\n        let time_until_delay_change = if new > current {\n            // Increasing the delay value can therefore be done immediately: this does not invalidate prior constraints\n            // about how quickly a value might be changed (indeed it strengthens them).\n            //\n            //\n            //                                Earliest `svc.timestamp_of_change`,     Earliest `svc.timestamp_of_change`\n            //   `current_timestamp`          if the delay had remained unchanged     immediately after this scheduling fn.\n            //      v                                                          v              v\n            //  ====|==========================================================|==============|==>\n            //      |                                                          |              |\n            //      [------------------`current` delay-------------------------]              |\n            //      |                                                                         |\n            //      [-------------------------`new` (longer) delay----------------------------]\n            //      |\n            //      [] <--- `time_until_delay_change` is `0`; the change is immediate.\n            //      |\n            //      ^\n            //      The newly-calculated `self.timestamp_of_change` (unchanged)\n\n            0\n        } else {\n            // Decreasing the delay requires waiting for the difference between current and new delay in order to ensure\n            // that overall the current delay is respected.\n            //\n            //\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //                                                   if the delay had remained unchanged\n            //                                                   AND\n            //                                                   Earliest `svc.timestamp_of_change`,\n            //   `current_timestamp`                             immediately after this scheduling fn.\n            //  ====|============================|=============================|=================>\n            //      |                                                          |\n            //      [---------------------`current` delay----------------------]\n            //                                   |                             |\n            //                                   [- --`new` (shorter) delay----]\n            //                                   |                             ^\n            //      [-`time_until_delay_change`--]                             |\n            //                                   |                             |\n            //                                   ^                             |\n            //                                   The newly-calculated          |\n            //                                  `self.timestamp_of_change`     |\n            //                                                                 |\n            //                                                      The new `self.timestamp_of_change`\n            //                                                      is calculated so that these ends\n            //                                                      align.\n            current - new\n        };\n\n        self.pre = Option::some(current);\n        self.post = Option::some(new);\n        self.timestamp_of_change = current_timestamp + time_until_delay_change;\n    }\n\n    /// Returns the minimum delay before a value might mutate due to a scheduled change, from the perspective of some\n    /// anchor block timestamp. It only returns a meaningful value when called in private with anchor block timestamps.\n    /// The output of this function can be passed into `ScheduledValueChange.get_time_horizon` to properly\n    /// constrain the `expiration_timestamp` when reading delayed mutable state.\n    /// This value typically equals the current delay at the timestamp following the anchor block one (the earliest one\n    /// in which a value change could be scheduled), but it also considers scenarios in which a delay reduction is\n    /// scheduled to happen in the near future, resulting in a way to schedule a change with an overall delay lower than\n    /// the current one.\n    ///\n    /// Alternative explanation: returns the maximum amount of time (from the anchor block timestamp) that a state read\n    /// (as at the anchor block timestamp) will remain valid.\n    /// A read might end up being valid for less time in the case where a `svc.timestamp_of_change` has already been\n    /// set and if it's sooner than the output of this function. In that case, the `scheduled_value_change.nr`'s\n    /// `get_time_horizon` function will realize this.\n    ///\n    pub fn get_effective_minimum_delay_at(self, anchor_block_timestamp: u64) -> u64 {\n        // If a change is scheduled, then the effective delay might be lower than the current one (pre). At the\n        // timestamp of change the current delay will be the scheduled one, with an overall delay from the anchor block\n        // timestamp equal to the time until the change plus the new delay. If this value is lower\n        // than the current delay, then that is the effective minimum delay.\n\n        // If using some block as the anchor block of some tx, then note that if you\n        // read a `delayed_mutable` from that anchor block, you're actually reading the\n        // `delayed_mutable` _as at the very end_ of that block.\n        // Therefore the `delayed_mutable` that you will read _as at the very start of the next\n        // block_ will be _the very same_ `delayed_mutable` (nothing can possibly have changed).\n        // Therefore the first opportunity to schedule a value change (from the anchor block timestamp)\n        // is the first tx of a subsequent block. Blocks within the same checkpoint can share\n        // timestamps, so the earliest scheduling timestamp can equal the anchor block timestamp.\n        // So should you choose to go ahead and schedule a value change in a subsequent block,\n        // it will only take effect after the \"current\" delay (as dictated by the\n        // `delayed_mutable` of that tx, which is the same as the `delayed_mutable` as at the\n        // anchor block timestamp).\n        // In all, the time between the anchor block's timestamp and the earliest-possible value\n        // timestamp_of_change, is therefore: the \"current\" delay (as at the time of the anchor\n        // timestamp).\n        // Reads must only be valid until _just before_ the earliest-possible value change --\n        // i.e. 1 second before the earliest-possible value change.\n        // That is, reads are only valid for the \"current\" delay (as at the time of the anchor\n        // block timestamp) _at most_.\n        //\n        //  ____________                               ____________\n        // |            |                             |            |\n        // |  Block     |<-- 0 or more seconds gap -->|  Block     |\n        // |____________|                             |____________|\n        //              ^                              ^\n        //              |                              You can schedule a value change from here.\n        //              |\n        //    Suppose this is your anchor block.\n        //    The delayed_mutable (and hence the \"current\" delay) as at the end of this block will\n        //    be the same as at the start of the next block.\n        //\n        if self.timestamp_of_change <= anchor_block_timestamp {\n            //\n            //              `self.timestamp_of_change` <= `anchor_block_timestamp`\n            //                    v                              v\n            // ===================|==============================|=========\n            // ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            // `self.pre` is      |`self.post` takes effect from here.\n            // effective before.  |\n            //\n            // So in this `if` case, `self.post` is in effect at the time of the `anchor_block_timestamp`.\n            //\n            // If no delay changes are scheduled (as at the time of the anchor timestamp), then the \"current delay\" (as\n            // at the time of the anchor block timestamp) is `self.post - 1` (or the `INITIAL_DELAY - 1` if never set).\n            self.post.unwrap_or(INITIAL_DELAY) - 1\n        } else {\n            //\n            //          `anchor_block_timestamp` < `self.timestamp_of_change`\n            //                                           v\n            // ===================|======================|====================================\n            // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //           `self.pre` is effective         |`self.post` takes effect from here.\n            //           during this period.             |\n            //\n            //\n            // So in this `else` case, `self.pre` is in effect at the time of the `anchor_block_timestamp`.\n            //\n            //\n            //\n            // If a delay change _is_ already scheduled (as at the time of the anchor block timestamp):\n            //      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n            //                   |________________\n            //                                    |\n            //                                    v                          Earliest possible\n            //  `anchor_block_          Scheduled delay change:               `svc.timestamp_of_change`\n            //  timestamp`      <      `self.timestamp_of_change`            (if not already set [^1])\n            //     v                              v                                    v\n            //  ===|==============================|====================================|================>\n            //     |                              .                                    .\n            //     |                              .                                    .\n            //     |__ Earliest possible timestamp at which a                          .\n            //     .    function could call `schedule_change` for a new                .\n            //     .    _value_ change.................................................| And the earliest timestamp at\n            //     .                              .                                    . which the new value would take effect,\n            //     .                              .                                    . as dictated by `self.pre`.\n            //     .                              .                                    .\n            //     [---------------`self.pre` delay------------------------------------]\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     ********************************************************************.\n            //     *                                                                  *.\n            //     [----------------`self.pre - 1`------------------------------------].\n            //     *                                                                  *.\n            //     * If reading a _value_ at that (<--) anchor timestamp, then the    *.\n            //     * read will remain valid for this duration, unless a shorter       *.\n            //     * delay has been scheduled (see just below in this diagram).       *.\n            //     * See the `min` calc in the code below.                            *.\n            //     *                                                                  *.\n            //     * Future enhancement, recorded here so we don't have to            *.\n            //     * re-remember it:                                                  *.\n            //     * If a _deferred, longer_ delay has been scheduled (not yet        *.\n            //     * possible), it might yet still be cancelled, in which case this   *.\n            //     * `pre - 1` delay would also bite (meaning reads would remain      *.\n            //     * valid for this duration).                                        *.\n            //     *                                                                  *.\n            //     ********************************************************************.\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     [---`time_until_delay_change`--]                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 1: an already-scheduled delay is shorter than the `self.pre` delay:\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay-]                .\n            //     .                              . (if shorter      ^^                .\n            //     .                              .  than `pre`)     ||_ new values can take effect from here.\n            //     .                              .                  |\n            //     .                              .                  |_ reads are only valid until here:\n            //     .                              .                  .  `anchor_block_timestamp + time_until_delay_change + self.post - 1`\n            //     .                              .                  .                 .\n            //     ***************************************************                 .\n            //     *                                                 *                 .\n            //     [----`time_until_delay_change + self.post - 1`----]                 .\n            //     *                                                 *                 .\n            //     * If reading a _value_ at that (<--) anchor       *                 .\n            //     * timestamp, then the read will remain valid      *                 .\n            //     * for this duration:                              *                 .\n            //     *                                                 *                 .\n            //     ***************************************************                 .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     SCENARIO 2: an already-scheduled delay is longer than the `self.pre` delay, AND is deferred:\n            //     (note: scheduling deferred delay changes is not yet possible)\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              .                                    .\n            //     .                              [-`self.post` delay (if longer than `pre` & deferred)------------------]\n            //     .                              .  (scheduling deferred delay changes is not yet possible)            ^^\n            //     .                              .                                                                     ||\n            //     .                              .     reads would only be valid until here:___________________________||\n            //     .                              .     `anchor_block_timestamp + time_until_delay_change + self.post - 1` |\n            //     .                              .                                                                      |\n            //     .                              .                        new values would take effect from here,_______|\n            //     .                              .                        but only once this longer delay takes effect  .\n            //     .                              .                                    .                                 .\n            //     .                              .                                    .                                 .\n            //     .                              .                                    .                                 .\n            //     ******************************************************************************************************.\n            //     *                                                                                                    *.\n            //     [----`time_until_delay_change + self.post - 1`-------------------------------------------------------].\n            //     *                                                                                                    *.\n            //     * Given a longer, deferred delay, then if reading a _value_ at that (<--) anchor block timestamp, then *.\n            //     * you might think the read would remain valid for this duration.                                     *.\n            //     * BUT, in this case of this deferred, longer-than-`self.pre` delay, the `pre` delay ends sooner (by  *.\n            //     * construction) (see above in this diagram).                                                         *.\n            //     * And since this scheduled delay (`post`) can be cancelled up until the time it takes effect,        *.\n            //     * any reads as at that (<--) anchor block timestamp would cautiously only be valid until the earlier   *.\n            //     * `pre` delay expiry.                                                                                *.\n            //     *                                                                                                    *.\n            //     ******************************************************************************************************.\n            //\n            //\n            //\n            // [^1] If a svc.timestamp_of_change has already been set, and if it's sooner than the\n            //      output of this function, then it will bite within `scheduled_value_change.nr`'s\n            //      `get_time_horizon` function.\n            let time_until_delay_change = self.timestamp_of_change - anchor_block_timestamp;\n\n            let time_until_next_delay_change = min(\n                self.pre.unwrap_or(INITIAL_DELAY), // in case the scheduled delay (`post`) gets cancelled before it takes effect.\n                time_until_delay_change + self.post.unwrap_or(INITIAL_DELAY),\n            );\n\n            // The effective minimum delay equals the minimum time until a value change, minus 1, since reads are\n            // valid only up to (but not including) the moment the value can change.\n            time_until_next_delay_change - 1\n        }\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Eq for ScheduledDelayChange<INITIAL_DELAY> {\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<let INITIAL_DELAY: u64> Empty for ScheduledDelayChange<INITIAL_DELAY> {\n    fn empty() -> Self {\n        Self { pre: Option::none(), post: Option::none(), timestamp_of_change: 0 }\n    }\n}\n"
     },
-    "175": {
+    "176": {
       "function_locations": [
         {
           "name": "ScheduledValueChange<T>::new",
@@ -1035,10 +1047,10 @@
           "start": 8987
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/delayed_public_mutable/scheduled_value_change.nr",
       "source": "use crate::traits::Empty;\nuse std::cmp::min;\n\nmod test;\n\n// This data structure is used by DelayedPublicMutable to represent a value that changes from `pre` to `post` at some timestamp\n// called the `timestamp_of_change`. The value can only be made to change by scheduling a change event at some future\n// timestamp after some minimum delay measured in seconds has elapsed. This means that at any given timestamp we know\n// both the current value and the smallest timestamp at which the value might change - this is called the\n// 'time horizon'.\npub struct ScheduledValueChange<T> {\n    pub(crate) pre: T,\n    pub(crate) post: T,\n    // Timestamp at which `post` value is used instead of `pre`\n    pub(crate) timestamp_of_change: u64,\n}\n\nimpl<T> ScheduledValueChange<T> {\n    pub fn new(pre: T, post: T, timestamp_of_change: u64) -> Self {\n        Self { pre, post, timestamp_of_change }\n    }\n\n    /// Returns the value stored in the data structure at a given timestamp. This function can be called both in public\n    /// (where `timestamp` is simply the current timestamp, i.e. the timestamp at which the current transaction will be\n    /// included) and in private (where `timestamp` is the anchor block's timestamp). Reading in private is only safe\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon (see\n    /// `get_time_horizon()`).\n    pub fn get_current_at(self, timestamp: u64) -> T {\n        // The post value becomes the current one at the timestamp of change. This means different things in each realm:\n        // - in public, any transaction that is included at the timestamp of change will use the post value\n        // - in private, any transaction that includes the timestamp of change as part of the historical state will use\n        //   the post value (barring any follow-up changes)\n        if timestamp < self.timestamp_of_change {\n            self.pre\n        } else {\n            self.post\n        }\n    }\n\n    /// Returns the scheduled change, i.e. the post-change value and the timestamp at which it will become the current\n    /// value. Note that this timestamp may be in the past if the change has already taken place.\n    /// Additionally, further changes might be later scheduled, potentially canceling the one returned by this function.\n    pub fn get_scheduled(self) -> (T, u64) {\n        (self.post, self.timestamp_of_change)\n    }\n\n    // Returns the previous value. This is the value that is current up until the timestamp of change. Note that this\n    // value might not be the current anymore since timestamp of change might have already passed.\n    pub fn get_previous(self) -> (T, u64) {\n        (self.pre, self.timestamp_of_change)\n    }\n\n    /// Returns the largest timestamp at which the value returned by `get_current_at` is known to remain the current\n    /// value. This value is only meaningful in private where the proof is constructed against an anchor block, since\n    /// due to its asynchronous nature private execution cannot know about any later scheduled changes.\n    /// The caller of this function must know how quickly the value can change due to a scheduled change in the form of\n    /// `minimum_delay`. If the delay itself is immutable, then this is just its duration. If the delay is mutable\n    /// however, then this value is the 'effective minimum delay' (obtained by calling\n    /// `ScheduledDelayChange.get_effective_minimum_delay_at`), which equals the minimum time in seconds that needs to\n    /// elapse from the next block's timestamp until the value changes, regardless of further delay changes.\n    /// The value returned by `get_current_at` in private when called with a anchor block's timestamp is only safe to use\n    /// if the transaction's `expiration_timestamp` property is set to a value lower or equal to the time horizon\n    /// computed using the same anchor timestamp.\n    pub fn get_time_horizon(self, anchor_block_timestamp: u64, minimum_delay: u64) -> u64 {\n        // The time horizon is the very last timestamp in which the current value is known. Any timestamp past the\n        // horizon (i.e. with a timestamp larger than the time horizon) may have a different current value.\n        // Reading the current value in private typically requires constraining the maximum valid timestamp to be equal\n        // to the time horizon.\n        if anchor_block_timestamp >= self.timestamp_of_change {\n            // Once the timestamp of change has passed (block with timestamp >= timestamp_of_change was mined),\n            // the current value (post) will not change unless a new value change is scheduled. This did not happen at\n            // the anchor timestamp (or else it would not be greater or equal to the timestamp of change), and\n            // therefore could only happen after the anchor timestamp. The earliest would be the immediate next\n            // timestamp, and so the smallest possible next timestamp of change equals `anchor_block_timestamp + 1 +\n            // minimum_delay`. Our time horizon is simply the previous timestamp to that one.\n            //\n            //   timestamp of    anchor\n            //      change       timestamp          time horizon\n            //   =======|=============N===================H===========>\n            //                         ^                   ^\n            //                         ---------------------\n            //                             minimum delay\n            anchor_block_timestamp + minimum_delay\n        } else {\n            // If the timestamp of change has not yet been reached however, then there are two possible scenarios.\n            //   a) It could be so far into the future that the time horizon is actually determined by the minimum\n            //      delay, because a new change could be scheduled and take place _before_ the currently scheduled one.\n            //      This is similar to the scenario where the timestamp of change is in the past: the time horizon is\n            //      the timestamp prior to the earliest one in which a new timestamp of change might land.\n            //\n            //         anchor\n            //         timestamp                      time horizon    timestamp of change\n            //        =====N=================================H=================|=========>\n            //              ^                                 ^\n            //              |                                 |\n            //              -----------------------------------\n            //                        minimum delay\n            //\n            //   b) It could be fewer than `minimum_delay` seconds away from the anchor timestamp, in which case\n            //      the timestamp of change would become the limiting factor for the time horizon, which would equal\n            //      the timestamp right before the timestamp of change (since by definition the value changes at the\n            //      timestamp of change).\n            //\n            //           anchor                         time horizon\n            //           timestamp   timestamp of change    if not scheduled\n            //        =======N=============|===================H=================>\n            //                ^           ^                     ^\n            //                |     actual horizon              |\n            //                -----------------------------------\n            //                          minimum delay\n            //\n            // Note that the current implementation does not allow the caller to set the timestamp of change to an\n            // arbitrary value, and therefore scenario a) is not currently possible. However implementing #5501 would\n            // allow for this to happen.\n            // Because anchor_block_timestamp < self.timestamp_of_change, then timestamp_of_change > 0 and we can safely\n            // subtract 1.\n            min(\n                anchor_block_timestamp + minimum_delay,\n                self.timestamp_of_change - 1,\n            )\n        }\n    }\n\n    /// Mutates the value by scheduling a change at the current timestamp. This function is only meaningful when\n    /// called in public with the current timestamp.\n    pub fn schedule_change(\n        &mut self,\n        new_value: T,\n        current_timestamp: u64,\n        minimum_delay: u64,\n        timestamp_of_change: u64,\n    ) {\n        assert(timestamp_of_change >= current_timestamp + minimum_delay);\n\n        self.pre = self.get_current_at(current_timestamp);\n        self.post = new_value;\n        self.timestamp_of_change = timestamp_of_change;\n    }\n}\n\nimpl<T> Eq for ScheduledValueChange<T>\nwhere\n    T: Eq,\n{\n    fn eq(self, other: Self) -> bool {\n        (self.pre == other.pre)\n            & (self.post == other.post)\n            & (self.timestamp_of_change == other.timestamp_of_change)\n    }\n}\n\nimpl<T> Empty for ScheduledValueChange<T>\nwhere\n    T: Empty,\n{\n    fn empty() -> Self {\n        Self { pre: T::empty(), post: T::empty(), timestamp_of_change: 0 }\n    }\n}\n"
     },
-    "178": {
+    "179": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -1157,10 +1169,10 @@
           "start": 16359
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "180": {
+    "181": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -1231,20 +1243,20 @@
           "start": 2802
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "198": {
+    "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",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/point.nr",
       "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"
     },
-    "206": {
+    "207": {
       "function_locations": [
         {
           "name": "hash_public_key",
@@ -1311,10 +1323,10 @@
           "start": 7756
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/types/src/public_keys.nr",
       "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    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    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    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    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    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    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    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    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"
     },
-    "211": {
+    "212": {
       "function_locations": [
         {
           "name": "derive_storage_slot_in_map",
@@ -1325,10 +1337,10 @@
           "start": 587
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "238": {
+    "239": {
       "function_locations": [
         {
           "name": "Poseidon2::hash",
@@ -1370,7 +1382,7 @@
       "path": "/home/aztec-dev/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon2.nr",
       "source": "use std::default::Default;\nuse std::hash::Hasher;\n\nglobal RATE: u32 = 3;\n\npub struct Poseidon2 {\n    cache: [Field; 3],\n    state: [Field; 4],\n    cache_size: u32,\n    squeeze_mode: bool, // 0 => absorb, 1 => squeeze\n}\n\nimpl Poseidon2 {\n    #[no_predicates]\n    pub fn hash<let N: u32>(input: [Field; N], message_size: u32) -> Field {\n        Poseidon2::hash_internal(input, message_size)\n    }\n\n    pub(crate) fn new(iv: Field) -> Poseidon2 {\n        let mut result =\n            Poseidon2 { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false };\n        result.state[RATE] = iv;\n        result\n    }\n\n    fn perform_duplex(&mut self) {\n        // add the cache into sponge state\n        self.state[0] += self.cache[0];\n        self.state[1] += self.cache[1];\n        self.state[2] += self.cache[2];\n        self.state = crate::poseidon2_permutation(self.state);\n    }\n\n    fn absorb(&mut self, input: Field) {\n        assert(!self.squeeze_mode);\n        if self.cache_size == RATE {\n            // If we're absorbing, and the cache is full, apply the sponge permutation to compress the cache\n            self.perform_duplex();\n            self.cache[0] = input;\n            self.cache_size = 1;\n        } else {\n            // If we're absorbing, and the cache is not full, add the input into the cache\n            self.cache[self.cache_size] = input;\n            self.cache_size += 1;\n        }\n    }\n\n    fn squeeze(&mut self) -> Field {\n        assert(!self.squeeze_mode);\n        // If we're in absorb mode, apply sponge permutation to compress the cache.\n        self.perform_duplex();\n        self.squeeze_mode = true;\n\n        // Pop one item off the top of the permutation and return it.\n        self.state[0]\n    }\n\n    fn hash_internal<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n        let two_pow_64 = 18446744073709551616;\n        let iv: Field = (in_len as Field) * two_pow_64;\n        let mut state = [0; 4];\n        state[RATE] = iv;\n\n        if std::runtime::is_unconstrained() {\n            for i in 0..(in_len / RATE) {\n                state[0] += input[i * RATE];\n                state[1] += input[i * RATE + 1];\n                state[2] += input[i * RATE + 2];\n                state = crate::poseidon2_permutation(state);\n            }\n\n            // handle remaining elements after last full RATE-sized chunk\n            let num_extra_fields = in_len % RATE;\n            if num_extra_fields != 0 {\n                let remainder_start = in_len - num_extra_fields;\n                state[0] += input[remainder_start];\n                if num_extra_fields > 1 {\n                    state[1] += input[remainder_start + 1];\n                }\n            }\n        } else {\n            let mut states: [[Field; 4]; N / RATE + 1] = [[0; 4]; N / RATE + 1];\n            states[0] = state;\n\n            // process all full RATE-sized chunks, storing state after each permutation\n            for chunk_idx in 0..(N / RATE) {\n                for i in 0..RATE {\n                    state[i] += input[chunk_idx * RATE + i];\n                }\n                state = crate::poseidon2_permutation(state);\n                states[chunk_idx + 1] = state;\n            }\n\n            // get state at the last full block before in_len\n            let first_partially_filled_chunk = in_len / RATE;\n            state = states[first_partially_filled_chunk];\n\n            // handle remaining elements after last full RATE-sized chunk\n            let remainder_start = (in_len / RATE) * RATE;\n            for j in 0..RATE {\n                let idx = remainder_start + j;\n                if idx < in_len {\n                    state[j] += input[idx];\n                }\n            }\n        }\n\n        // always run final permutation unless we just completed a full chunk\n        // still need to permute once if in_len is 0\n        if (in_len == 0) | (in_len % RATE != 0) {\n            state = crate::poseidon2_permutation(state);\n        };\n\n        state[0]\n    }\n}\n\npub struct Poseidon2Hasher {\n    _state: [Field],\n}\n\nimpl Hasher for Poseidon2Hasher {\n    fn finish(self) -> Field {\n        let iv: Field = (self._state.len() as Field) * 18446744073709551616; // iv = (self._state.len() << 64)\n        let mut sponge = Poseidon2::new(iv);\n        for i in 0..self._state.len() {\n            sponge.absorb(self._state[i]);\n        }\n        sponge.squeeze()\n    }\n\n    fn write(&mut self, input: Field) {\n        self._state = self._state.push_back(input);\n    }\n}\n\nimpl Default for Poseidon2Hasher {\n    fn default() -> Self {\n        Poseidon2Hasher { _state: @[] }\n    }\n}\n"
     },
-    "241": {
+    "242": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -1417,10 +1429,10 @@
           "start": 1426
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/reader.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/reader.nr",
       "source": "pub struct Reader<let N: u32> {\n    data: [Field; N],\n    offset: u32,\n}\n\nimpl<let N: u32> Reader<N> {\n    pub fn new(data: [Field; N]) -> Self {\n        Self { data, offset: 0 }\n    }\n\n    pub fn read(&mut self) -> Field {\n        let result = self.data[self.offset];\n        self.offset += 1;\n        result\n    }\n\n    pub fn read_u32(&mut self) -> u32 {\n        self.read() as u32\n    }\n\n    pub fn read_u64(&mut self) -> u64 {\n        self.read() as u64\n    }\n\n    pub fn read_bool(&mut self) -> bool {\n        self.read() != 0\n    }\n\n    pub fn read_array<let K: u32>(&mut self) -> [Field; K] {\n        let mut result = [0; K];\n        for i in 0..K {\n            result[i] = self.data[self.offset + i];\n        }\n        self.offset += K;\n        result\n    }\n\n    pub fn read_struct<T, let K: u32>(&mut self, deserialise: fn([Field; K]) -> T) -> T {\n        let result = deserialise(self.read_array());\n        result\n    }\n\n    pub fn read_struct_array<T, let K: u32, let C: u32>(\n        &mut self,\n        deserialise: fn([Field; K]) -> T,\n        mut result: [T; C],\n    ) -> [T; C] {\n        for i in 0..C {\n            result[i] = self.read_struct(deserialise);\n        }\n        result\n    }\n\n    pub fn peek_offset(&mut self, offset: u32) -> Field {\n        self.data[self.offset + offset]\n    }\n\n    pub fn advance_offset(&mut self, offset: u32) {\n        self.offset += offset;\n    }\n\n    pub fn finish(self) {\n        assert_eq(self.offset, self.data.len(), \"Reader did not read all data\");\n    }\n}\n"
     },
-    "242": {
+    "243": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -1443,10 +1455,10 @@
           "start": 12477
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/serialization.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-protocol-circuits/crates/serde/src/serialization.nr",
       "source": "use crate::{reader::Reader, writer::Writer};\n\n/// Trait for serializing Noir types into arrays of Fields.\n///\n/// An implementation of the Serialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait (and Deserialize) are\n/// typically used to communicate between Noir and TypeScript (via oracles and function arguments).\n///\n/// # On Following Noir's Intrinsic Serialization\n/// When calling a Noir function from TypeScript (TS), first the function arguments are serialized into an array\n/// of fields. This array is then included in the initial witness. Noir's intrinsic serialization is then used\n/// to deserialize the arguments from the witness. When the same Noir function is called from Noir this Serialize trait\n/// is used instead of the serialization in TS. For this reason we need to have a match between TS serialization,\n/// Noir's intrinsic serialization and the implementation of this trait. If there is a mismatch, the function calls\n/// fail with an arguments hash mismatch error message.\n///\n/// # Associated Constants\n/// * `N` - The length of the output Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<let N: u32> Serialize for str<N> {\n///     let N: u32 = N;\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///     fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n///         let bytes = self.as_bytes();\n///         for i in 0..bytes.len() {\n///             writer.write(bytes[i] as Field);\n///         }\n///     }\n/// }\n/// ```\n#[derive_via(derive_serialize)]\npub trait Serialize {\n    let N: u32;\n\n    fn serialize(self) -> [Field; Self::N];\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>);\n}\n\n/// Generates a `Serialize` trait implementation for a struct type.\n///\n/// # Parameters\n/// - `s`: The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A quoted code block containing the trait implementation\n///\n/// # Example\n/// For a struct defined as:\n/// ```\n/// struct Log<N> {\n///     fields: [Field; N],\n///     length: u32\n/// }\n/// ```\n///\n/// This function generates code equivalent to:\n/// ```\n/// impl<let N: u32> Serialize for Log<N> {\n///     let N: u32 = <[Field; N] as Serialize>::N + <u32 as Serialize>::N;\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///         Serialize::stream_serialize(self.fields, writer);\n///         Serialize::stream_serialize(self.length, writer);\n///     }\n/// }\n/// ```\npub comptime fn derive_serialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n\n    // We care only about the name and type so we drop the last item of the tuple\n    let params = nested_struct.0.fields(nested_struct.1).map(|(name, typ, _)| (name, typ));\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Serialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_serialize_clause = get_where_trait_clause(s, quote { Serialize });\n\n    let params_len_quote = get_params_len_quote(params);\n\n    let function_body = params\n        .map(|(name, _typ): (Quoted, Type)| {\n            quote {\n                $crate::serialization::Serialize::stream_serialize(self.$name, writer);\n            }\n        })\n        .join(quote {});\n\n    quote {\n        impl$generics_declarations $crate::serialization::Serialize for $typ\n            $where_serialize_clause\n        {\n            let N: u32 = $params_len_quote;\n\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                $crate::serialization::Serialize::stream_serialize(self, &mut writer);\n                writer.finish()\n            }\n\n\n            #[inline_always]\n             fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Trait for deserializing Noir types from arrays of Fields.\n///\n/// An implementation of the Deserialize trait has to follow Noir's intrinsic serialization (each member of a struct\n/// converted directly into one or more Fields without any packing or compression). This trait is typically used when\n/// deserializing return values from function calls in Noir. Since the same function could be called from TypeScript\n/// (TS), in which case the TS deserialization would get used, we need to have a match between the 2.\n///\n/// # Associated Constants\n/// * `N` - The length of the input Field array, known at compile time\n///\n/// # Example\n/// ```\n/// impl<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///     fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n///         let mut bytes = [0 as u8; M];\n///         for i in 0..M {\n///             bytes[i] = reader.read() as u8;\n///         }\n///         str::<M>::from(bytes)\n///     }\n/// }\n/// ```\n#[derive_via(derive_deserialize)]\npub trait Deserialize {\n    let N: u32;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self;\n\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self;\n}\n\n/// Generates a `Deserialize` trait implementation for a given struct `s`.\n///\n/// # Arguments\n/// * `s` - The struct type definition to generate the implementation for\n///\n/// # Returns\n/// A `Quoted` block containing the generated trait implementation\n///\n/// # Requirements\n/// Each struct member type must implement the `Deserialize` trait (it gets used in the generated code).\n///\n/// # Example\n/// For a struct like:\n/// ```\n/// struct MyStruct {\n///     x: AztecAddress,\n///     y: Field,\n/// }\n/// ```\n///\n/// This generates:\n/// ```\n/// impl Deserialize for MyStruct {\n///     let N: u32 = <AztecAddress as Deserialize>::N + <Field as Deserialize>::N;\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 x = <AztecAddress as Deserialize>::stream_deserialize(reader);\n///         let y = <Field as Deserialize>::stream_deserialize(reader);\n///         Self { x, y }\n///     }\n/// }\n/// ```\npub comptime fn derive_deserialize(s: TypeDefinition) -> Quoted {\n    let typ = s.as_type();\n    let nested_struct = typ.as_data_type().unwrap();\n    let params = nested_struct.0.fields(nested_struct.1);\n\n    // Generates the generic parameter declarations (to be placed after the `impl` keyword) and the `where` clause\n    // for the `Deserialize` trait.\n    let generics_declarations = get_generics_declarations(s);\n    let where_deserialize_clause = get_where_trait_clause(s, quote { Deserialize });\n\n    // The following will give us:\n    // <type_of_struct_member_1 as Deserialize>::N + <type_of_struct_member_2 as Deserialize>::N + ...\n    // (or 0 if the struct has no members)\n    let right_hand_side_of_definition_of_n = if params.len() > 0 {\n        params\n            .map(|(_, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n            <$param_type as $crate::serialization::Deserialize>::N\n        }\n            })\n            .join(quote {+})\n    } else {\n        quote { 0 }\n    };\n\n    // For structs containing a single member, we can enhance performance by directly deserializing the input array,\n    // bypassing the need for loop-based array construction. While this optimization yields significant benefits in\n    // Brillig where the loops are expected to not be optimized, it is not relevant in ACIR where the loops are\n    // expected to be optimized away.\n    let function_body = if params.len() > 1 {\n        // This generates deserialization code for each struct member and concatenates them together.\n        let deserialization_of_struct_members = params\n            .map(|(param_name, param_type, _): (Quoted, Type, Quoted)| {\n                quote {\n                    let $param_name = <$param_type as Deserialize>::stream_deserialize(reader);\n                }\n            })\n            .join(quote {});\n\n        // We join the struct member names with a comma to be used in the `Self { ... }` syntax\n        // This will give us e.g. `a, b, c` for a struct with three fields named `a`, `b`, and `c`.\n        let struct_members = params\n            .map(|(param_name, _, _): (Quoted, Type, Quoted)| quote { $param_name })\n            .join(quote {,});\n\n        quote {\n            $deserialization_of_struct_members\n\n            Self { $struct_members }\n        }\n    } else if params.len() == 1 {\n        let param_name = params[0].0;\n        quote {\n            Self { $param_name: $crate::serialization::Deserialize::stream_deserialize(reader) }\n        }\n    } else {\n        quote {\n            Self {}\n        }\n    };\n\n    quote {\n        impl$generics_declarations $crate::serialization::Deserialize for $typ\n            $where_deserialize_clause\n        {\n            let N: u32 = $right_hand_side_of_definition_of_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 $crate::reader::Reader<K>) -> Self {\n                $function_body\n            }\n        }\n    }\n}\n\n/// Generates a quoted expression that computes the total serialized length of function parameters.\n///\n/// # Parameters\n/// * `params` - An array of tuples where each tuple contains a quoted parameter name and its Type. The type needs\n///              to implement the Serialize trait.\n///\n/// # Returns\n/// A quoted expression that evaluates to:\n/// * `0` if there are no parameters\n/// * `(<type1 as Serialize>::N + <type2 as Serialize>::N + ...)` for one or more parameters\ncomptime fn get_params_len_quote(params: [(Quoted, Type)]) -> Quoted {\n    if params.len() == 0 {\n        quote { 0 }\n    } else {\n        let params_quote_without_parentheses = params\n            .map(|(_, param_type): (Quoted, Type)| {\n                quote {\n                    <$param_type as $crate::serialization::Serialize>::N\n                }\n            })\n            .join(quote {+});\n        quote { ($params_quote_without_parentheses) }\n    }\n}\n\ncomptime fn get_generics_declarations(s: TypeDefinition) -> Quoted {\n    let generics = s.generics();\n\n    if generics.len() > 0 {\n        let generics_declarations_items = generics\n            .map(|(name, maybe_integer_typ)| {\n                // The second item in the generics tuple is an Option of an integer type that is Some only if\n                // the generic is numeric.\n                if maybe_integer_typ.is_some() {\n                    // The generic is numeric, so we return a quote defined as e.g. \"let N: u32\"\n                    let integer_type = maybe_integer_typ.unwrap();\n                    quote {let $name: $integer_type}\n                } else {\n                    // The generic is not numeric, so we return a quote containing the name of the generic (e.g. \"T\")\n                    quote { $name }\n                }\n            })\n            .join(quote {,});\n        quote {<$generics_declarations_items>}\n    } else {\n        // The struct doesn't have any generics defined, so we just return an empty quote.\n        quote {}\n    }\n}\n\ncomptime fn get_where_trait_clause(s: TypeDefinition, trait_name: Quoted) -> Quoted {\n    let generics = s.generics();\n\n    // The second item in the generics tuple is an Option of an integer type that is Some only if the generic is\n    // numeric.\n    let non_numeric_generics =\n        generics.filter(|(_, maybe_integer_typ)| maybe_integer_typ.is_none());\n\n    if non_numeric_generics.len() > 0 {\n        let non_numeric_generics_declarations =\n            non_numeric_generics.map(|(name, _)| quote {$name: $trait_name}).join(quote {,});\n        quote {where $non_numeric_generics_declarations}\n    } else {\n        // There are no non-numeric generics, so we return an empty quote.\n        quote {}\n    }\n}\n"
     },
-    "244": {
+    "245": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -1757,10 +1769,10 @@
           "start": 21246
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "42": {
+    "43": {
       "function_locations": [
         {
           "name": "Option<T>::none",
@@ -1938,7 +1950,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\nmod tests {\n    use crate::cmp::Ord;\n    use crate::cmp::Ordering;\n    use crate::default::Default as _;\n    use super::Option;\n\n    #[test]\n    fn some_and_none() {\n        assert(Option::<u8>::none().is_none());\n        assert(!Option::<u8>::none().is_some());\n        assert(Option::some(1).is_some());\n        assert(!Option::some(1).is_none());\n    }\n\n    #[test]\n    fn unwrap_succeeds() {\n        assert_eq(Option::some(1).unwrap(), 1);\n    }\n\n    #[test(should_fail)]\n    fn unwrap_fails() {\n        let _ = Option::<u8>::none().unwrap();\n    }\n\n    #[test]\n    fn unwrap_or() {\n        assert_eq(Option::some(1).unwrap_or(2), 1);\n        assert_eq(Option::none().unwrap_or(2), 2);\n    }\n\n    #[test]\n    fn unwrap_or_else() {\n        assert_eq(Option::some(1).unwrap_or_else(|| 2), 1);\n        assert_eq(Option::none().unwrap_or_else(|| 2), 2);\n    }\n\n    #[test]\n    fn expect_succeeds() {\n        assert_eq(Option::some(1).expect(f\"Should be there\"), 1);\n    }\n\n    #[test(should_fail_with = \"Should be there\")]\n    fn expect_fails() {\n        let _ = Option::<u8>::none().expect(f\"Should be there\");\n    }\n\n    #[test]\n    fn map() {\n        assert(Option::<u8>::none().map(|x| x + 1).is_none());\n        assert_eq(Option::some(1).map(|x| x + 1), Option::some(2));\n    }\n\n    #[test]\n    fn map_or() {\n        assert_eq(Option::<u8>::none().map_or(0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or(0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn map_or_else() {\n        assert_eq(Option::<u8>::none().map_or_else(|| 0, |x| x + 1), 0);\n        assert_eq(Option::some(1).map_or_else(|| 0, |x| x + 1), 2);\n    }\n\n    #[test]\n    fn and() {\n        assert_eq(Option::<u8>::none().and(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().and(Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and(Option::some(2)), Option::some(2));\n        assert_eq(Option::some(1).and(Option::none()), Option::none());\n    }\n\n    #[test]\n    fn and_then() {\n        assert_eq(Option::<u8>::none().and_then(|_| Option::<u8>::none()), Option::none());\n        assert_eq(Option::<u8>::none().and_then(|_| Option::some(1)), Option::none());\n        assert_eq(Option::some(1).and_then(|x| Option::some(x + 1)), Option::some(2));\n        assert_eq(Option::some(1).and_then(|_| Option::<u8>::none()), Option::none());\n    }\n\n    #[test]\n    fn or() {\n        assert_eq(Option::<u8>::none().or(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn or_else() {\n        assert_eq(Option::<u8>::none().or_else(|| Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().or_else(|| Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::some(2)), Option::some(1));\n        assert_eq(Option::some(1).or_else(|| Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn xor() {\n        assert_eq(Option::<u8>::none().xor(Option::none()), Option::none());\n        assert_eq(Option::<u8>::none().xor(Option::some(1)), Option::some(1));\n        assert_eq(Option::some(1).xor(Option::some(2)), Option::none());\n        assert_eq(Option::some(1).xor(Option::none()), Option::some(1));\n    }\n\n    #[test]\n    fn filter() {\n        assert_eq(Option::<u8>::none().filter(|_| true), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 1), Option::some(1));\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n        assert_eq(Option::some(1).filter(|x| x == 2), Option::none());\n    }\n\n    #[test]\n    fn flatten() {\n        assert_eq(Option::<Option<u8>>::none().flatten(), Option::none());\n        assert_eq(Option::some(Option::<u8>::none()).flatten(), Option::none());\n        assert_eq(Option::some(Option::some(1)).flatten(), Option::some(1));\n    }\n\n    #[test]\n    fn default() {\n        assert_eq(Option::<u8>::default(), Option::none());\n    }\n\n    #[test]\n    fn eq() {\n        assert(Option::<u8>::none() == Option::none());\n        assert(Option::<u8>::some(1) != Option::none());\n        assert(Option::<u8>::none() != Option::some(1));\n        assert(Option::<u8>::some(1) == Option::some(1));\n        assert(Option::<u8>::some(1) != Option::some(2));\n    }\n\n    #[test]\n    fn cmp() {\n        let none = Option::<u8>::none();\n        let one = Option::<u8>::some(1);\n        let two = Option::<u8>::some(2);\n        assert_eq(none.cmp(none), Ordering::equal());\n        assert_eq(none.cmp(one), Ordering::less());\n        assert_eq(one.cmp(none), Ordering::greater());\n        assert_eq(one.cmp(one), Ordering::equal());\n        assert_eq(one.cmp(two), Ordering::less());\n        assert_eq(two.cmp(one), Ordering::greater());\n    }\n}\n"
     },
-    "43": {
+    "44": {
       "function_locations": [
         {
           "name": "panic",
@@ -2262,7 +2274,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> Eq for (A,) {\n    fn eq(self, other: (A,)) -> bool {\n        self.0 == other.0\n    }\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> Ord for (A,) {\n    fn cmp(self, other: (A,)) -> Ordering {\n        self.0.cmp(other.0)\n    }\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 crate::meta::unquote;\n    use super::{Eq, max, min, Ord, Ordering};\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    #[test]\n    fn eq_unit() {\n        assert(().eq(()));\n    }\n\n    #[test]\n    fn eq_bool() {\n        assert(false.eq(false));\n        assert(!(false.eq(true)));\n        assert(!(true.eq(false)));\n        assert(true.eq(true));\n    }\n\n    #[test]\n    fn eq_integers() {\n        comptime {\n            for typ in @[\n                quote { u8 },\n                quote { i8 },\n                quote { u16 },\n                quote { i16 },\n                quote { u32 },\n                quote { i32 },\n                quote { u64 },\n                quote { i64 },\n                quote { u128 },\n                quote { Field },\n            ] {\n                let one = f\"1_{typ}\".quoted_contents();\n                let two = f\"2_{typ}\".quoted_contents();\n                unquote!(\n                    quote {\n                        assert($one.eq($one));\n                        assert(!($one.eq($two)));\n                    },\n                );\n            }\n        }\n    }\n\n    #[test]\n    fn eq_tuples() {\n        comptime {\n            for i in 1..=12 {\n                let mut tuple1 = @[];\n                let mut tuple2 = @[];\n                for _ in 0..i - 1 {\n                    tuple1 = tuple1.push_back(quote { 0 });\n                    tuple2 = tuple2.push_back(quote { 0 });\n                }\n                tuple1 = tuple1.push_back(quote { 0 });\n                tuple2 = tuple2.push_back(quote { 1 });\n                let tuple1 = tuple1.join(quote { , });\n                let tuple2 = tuple2.join(quote { , });\n                let tuple1 = quote { ($tuple1,) };\n                let tuple2 = quote { ($tuple2,) };\n                unquote!(\n                    quote {\n                    assert($tuple1.eq($tuple1));\n                    assert(!($tuple1.eq($tuple2)));\n                },\n                )\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_unit() {\n        assert_eq(().cmp(()), Ordering::equal());\n    }\n\n    #[test]\n    fn cmp_bool() {\n        assert_eq(false.cmp(true), Ordering::less());\n        assert_eq(false.cmp(false), Ordering::equal());\n        assert_eq(true.cmp(true), Ordering::equal());\n        assert_eq(true.cmp(false), Ordering::greater());\n    }\n\n    #[test]\n    fn cmp_integers() {\n        comptime {\n            for typ in @[\n                quote { u8 },\n                quote { i8 },\n                quote { u16 },\n                quote { i16 },\n                quote { u32 },\n                quote { i32 },\n                quote { u64 },\n                quote { i64 },\n                quote { u128 },\n            ] {\n                let one = f\"1_{typ}\".quoted_contents();\n                let two = f\"2_{typ}\".quoted_contents();\n                unquote!(\n                    quote {\n                        assert_eq($one.cmp($two), Ordering::less());\n                        assert_eq($one.cmp($one), Ordering::equal());\n                        assert_eq($two.cmp($one), Ordering::greater());\n                    },\n                );\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_tuples() {\n        comptime {\n            for i in 1..=12 {\n                let mut tuple1 = @[];\n                let mut tuple2 = @[];\n                for _ in 0..i - 1 {\n                    tuple1 = tuple1.push_back(quote { 0_u8 });\n                    tuple2 = tuple2.push_back(quote { 0_u8 });\n                }\n                tuple1 = tuple1.push_back(quote { 0_u8 });\n                tuple2 = tuple2.push_back(quote { 1_u8 });\n                let tuple1 = tuple1.join(quote { , });\n                let tuple2 = tuple2.join(quote { , });\n                let tuple1 = quote { ($tuple1,) };\n                let tuple2 = quote { ($tuple2,) };\n                unquote!(\n                    quote {\n                    assert_eq($tuple1.cmp($tuple1), Ordering::equal());\n                    assert_eq($tuple1.cmp($tuple2), Ordering::less());\n                    assert_eq($tuple2.cmp($tuple1), Ordering::greater());\n                },\n                )\n            }\n        }\n    }\n\n    #[test]\n    fn cmp_array() {\n        assert_eq([1_u8, 2, 3].cmp([1, 2, 3]), Ordering::equal());\n        assert_eq([1_u8, 2, 3].cmp([1, 3, 2]), Ordering::less());\n        assert_eq([1_u8, 3, 3].cmp([1, 2, 3]), Ordering::greater());\n    }\n\n    #[test]\n    fn cmp_vectors() {\n        // Equal lengths\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 2, 3]), Ordering::equal());\n        assert_eq(@[1_u8, 3, 3].cmp(@[1, 2, 3]), Ordering::greater());\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 3, 3]), Ordering::less());\n\n        // Different lengths\n        assert_eq(@[1_u8, 2].cmp(@[1, 2, 3]), Ordering::less());\n        assert_eq(@[1_u8, 2, 3].cmp(@[1, 2]), Ordering::greater());\n        assert_eq(@[10_u8, 0].cmp(@[9]), Ordering::greater());\n        assert_eq(@[9_u8, 0].cmp(@[10]), Ordering::less());\n        assert_eq(@[9_u8].cmp(@[10, 0]), Ordering::less());\n        assert_eq(@[10_u8].cmp(@[9, 0]), Ordering::greater());\n    }\n}\n"
     },
-    "51": {
+    "52": {
       "function_locations": [
         {
           "name": "ContractInstanceRegistry::ContractInstancePublished::serialize_non_standard",
@@ -2270,33 +2282,33 @@
         },
         {
           "name": "ContractInstanceRegistry::publish_for_public_execution",
-          "start": 5010
+          "start": 5208
         },
         {
           "name": "ContractInstanceRegistry::update",
-          "start": 9119
+          "start": 9317
         },
         {
           "name": "ContractInstanceRegistry::set_update_delay",
-          "start": 11330
+          "start": 11528
         },
         {
           "name": "ContractInstanceRegistry::get_update_delay",
-          "start": 12633
+          "start": 12831
         },
         {
           "name": "ContractInstanceRegistry::public_dispatch",
-          "start": 13785
+          "start": 13983
         },
         {
           "name": "ContractInstanceRegistry::Storage<Context>::init",
-          "start": 14918
+          "start": 15116
         }
       ],
-      "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"
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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    // Mirrors the private entrypoint the aztec-nr macro generates: PrivateCircuitPublicInputs has constant fields\n    // that cannot be dropped from the protocol ABI.\n    #[allow(constant_return)]\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"
     },
-    "56": {
+    "57": {
       "function_locations": [
         {
           "name": "PrivateContext::new",
@@ -2395,10 +2407,10 @@
           "start": 15805
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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            tx_request_salt: self.inputs.tx_request_salt,\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"
     },
-    "57": {
+    "58": {
       "function_locations": [
         {
           "name": "<impl Eq for PublicContext>::eq",
@@ -2525,10 +2537,10 @@
           "start": 10892
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "60": {
+    "61": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -2555,20 +2567,20 @@
           "start": 2994
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "69": {
+    "70": {
       "function_locations": [
         {
           "name": "compute_nullifier_existence_request",
           "start": 406
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/nullifier/utils.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "70": {
+    "71": {
       "function_locations": [
         {
           "name": "address",
@@ -2803,10 +2815,10 @@
           "start": 7247
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "78": {
+    "79": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -2833,10 +2845,10 @@
           "start": 2433
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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"
     },
-    "82": {
+    "83": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
@@ -2859,10 +2871,10 @@
           "start": 2151
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/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_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 = 30;\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"
     },
-    "83": {
+    "84": {
       "function_locations": [
         {
           "name": "<impl StateVariable<(M + 1), Context> for DelayedPublicMutable<T, InitialDelay, Context>>::new",
@@ -2925,10 +2937,10 @@
           "start": 26251
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/delayed_public_mutable.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/delayed_public_mutable.nr",
       "source": "use crate::protocol::{\n    delayed_public_mutable::{\n        delayed_public_mutable_values::{unpack_delay_change, unpack_value_change},\n        DelayedPublicMutableValues,\n        ScheduledDelayChange,\n        ScheduledValueChange,\n    },\n    traits::Packable,\n};\n\nuse crate::{context::{PrivateContext, PublicContext, UtilityContext}, state_vars::StateVariable, utils::WithHash};\n\n/// Mutable public values with private read access.\n///\n/// This is an advanced public state variable, with no native Solidity equivalent.\n///\n/// Like [`PublicMutable`](crate::state_vars::PublicMutable) it represents a public value of type `T` that can be\n/// written to repeatedly, but with a key improvement: the current value can also be **read from a private contract\n/// function**.\n///\n/// This comes at the cost of extra restrictions on the state variable: writes do not come into effect immediately,\n/// they must be **scheduled** to take place after some minimum delay. Reading from the state variable will therefore\n/// return the previous value until some time passes, which is why this is a _delayed_ mutable variable.\n///\n/// It is these delays that enable the capacity for reads from private contract functions, as they provide guarantees\n/// regarding how long can some historical state observed at the anchor block be known to not change.\n///\n/// Delays can be modified during the lifetime of the contract.\n///\n/// ## Access Patterns\n///\n/// The current value stored in a `DelayedPublicMutable` can be read from public contract functions, and writes can be\n/// scheduled to happen in the future.\n///\n/// Public contract functions can also schedule changes to the write delay, as well as inspect any already scheduled\n/// value or delay changes.\n///\n/// Private contract functions can read the **current** value of the state variable, but not past or scheduled values.\n/// They cannot read the current delay, and they cannot schedule any kind of value change.\n///\n/// ## Privacy\n///\n/// The value stored in `DelayedPublicMutable` is fully public, as are all scheduled value and delay changes.\n///\n/// Reads from a private contract function are almost fully private: the only observable effect is that they set the\n/// transaction's `expiration_timestamp` property, possibly reducing the privacy set. See\n/// [`PrivateContext::set_expiration_timestamp`](crate::context::PrivateContext::set_expiration_timestamp).\n///\n/// ## Use Cases\n///\n/// These are mostly an extension of [`PublicMutable`](crate::state_vars::PublicMutable)'s, given that what this state\n/// variable essentially achieves is to provide private reads to it. For example, it can be used for global contract\n/// configuration (such as fees, access control, etc.) that users will need to access during private interactions.\n///\n/// The key consideration is whether the enforced minimum delay on writes prevents using this state variable. In some\n/// scenarios this restriction is incompatible with requirements (such as a token's total supply, which must always be\n/// up to date), while in others the enhanced privacy might make the tradeoff acceptable (such as when dealing with\n/// contract pauses or access control revocation, where a delay of some hours could be acceptable).\n///\n/// Note that, just like in [`PublicMutable`](crate::state_vars::PublicMutable), the fact that the values are public\n/// does not necessarily mean the actions that update these values must themselves be wholly public. To learn more,\n/// see the notes there regarding usage of [`only_self`](crate::macros::functions::only_self).\n///\n/// ## Choosing Delays\n///\n/// A short delay reduces the most obvious downside of `DelayedPublicMutable`, and so it is natural to wish to make it\n/// be as low as possible. It is therefore important to understand the tradeoffs involved in delay selection.\n///\n/// A shorter delay will result in a lower `expiration_timestamp` property of transactions that privately read the\n/// state variable, reducing its privacy set. If the delay is smaller than that of any other contract, then this\n/// privacy leak might be large enough to uniquely identify those transactions that interact with the contract - fully\n/// defeating the purpose of `DelayedPublicMutable`.\n///\n/// Additionally, a lower `expiration_timestamp` obviously causes transactions to expire earlier, resulting in\n/// multiple issues. Among others, this can make large transactions that take long to prove be unfeasible, restrict\n/// users with slow proving devices, and force large transaction fees to guarantee fast inclusion.\n///\n/// In practice, a delay of at least a couple hours is recommended. From a privacy point of view the optimal delay is\n/// [`crate::protocol::constants::MAX_TX_LIFETIME`], which puts contracts in the same privacy set as those that do not\n/// use `DelayedPublicMutable` at all.\n///\n/// ## Examples\n///\n/// Declaring a `DelayedPublicMutable` in the contract's [`storage`](crate::macros::storage::storage) struct\n/// requires specifying the type `T` that is stored in the variable, along with the initial delay used when scheduling\n/// value changes:\n///\n/// ```noir\n/// global PAUSE_CONTRACT_INITIAL_DELAY_S: u64 = 6 * 60 * 60; // 6 hours\n/// global CHANGE_AUTHORIZATION_INITIAL_DELAY_S: u64 = 24 * 60 * 60; // 24 hours\n///\n/// #[storage]\n/// struct Storage<C> {\n///     paused: DelayedPublicMutable<bool, PAUSE_CONTRACT_INITIAL_DELAY_S, C>,\n///     user_authorization: Map<AztecAddress, DelayedPublicMutable<bool, CHANGE_AUTHORIZATION_INITIAL_DELAY_S, C>, C>,\n/// }\n/// ```\n///\n/// Note that this initial delay can be altered during the contract's lifetime via\n/// [`DelayedPublicMutable::schedule_delay_change`].\n///\n/// ## Requirements\n///\n/// The type `T` stored in the `DelayedPublicMutable` must implement the `Eq` and\n/// [`Packable`](crate::protocol::traits::Packable) traits.\n///\n/// ## Implementation Details\n///\n/// This state variable stores more information in public storage than\n/// [`PublicMutable`](crate::state_vars::PublicMutable), as it needs to keep track of the current and scheduled change\n/// information for both the value and the delay - see\n/// [`crate::protocol::delayed_public_mutable::DelayedPublicMutableValues`].\n///\n/// It also stores a hash of this entire configuration so that private reads can be performed in a single historical\n/// public storage read - see [`crate::utils::WithHash`].\n///\n/// This results in a total of `N * 2 + 2` storage slots used, where `N` is the packing length of the stored type `T`.\n/// This makes it quite important to ensure `T`'s implementation of [`Packable`](crate::protocol::traits::Packable) is\n/// space-efficient.\npub struct DelayedPublicMutable<T, let InitialDelay: u64, Context> {\n    context: Context,\n    storage_slot: Field,\n}\n\n// We allocate `M + 1` slots because we're going to store a `WithHash<DelayedPublicMutableValues<T, InitialDelay>>`,\n// and `WithHash` increases the packing length by one.\nimpl<T, let InitialDelay: u64, Context, let M: u32> StateVariable<M + 1, Context> for DelayedPublicMutable<T, InitialDelay, Context>\nwhere\n    DelayedPublicMutableValues<T, InitialDelay>: Packable<N = M>,\n{\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Self { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, PublicContext>\nwhere\n    T: Eq,\n{\n    /// Schedules a write to the current value.\n    ///\n    /// The current value does not immediately change. Once the current delay passes,\n    /// [`get_current_value`](DelayedPublicMutable::get_current_value) automatically begins to return `new_value`.\n    ///\n    /// ## Multiple Scheduled Changes\n    ///\n    /// Only a **single** value can be scheduled to become the new value at a given point in time. Any prior scheduled\n    /// changes which have not yet become current are **replaced** with the new one and discarded.\n    ///\n    /// To illustrate this, consider a scenario at `t0` with a current value `A`. A value change to `B` is scheduled to\n    /// occur at `t1`. At some point _before_ `t1`, a second value change to `C` is scheduled to occur at `t2` (`t2 >\n    /// t1`). The result is that the current value continues to be `A` all the way until `t2`, at which point it\n    /// changes to `C`.\n    ///\n    /// This also means that it is possible to **cancel** a scheduled change by calling `schedule_value_change` with\n    /// the current value.\n    ///\n    /// ## Examples\n    ///\n    /// A public setter that authorizes a user:\n    /// ```noir\n    /// #[external(\"public\")]\n    /// fn authorize_user(user: AztecAddress) {\n    ///     assert_eq(self.storage.admin.read(), self.msg_sender(), \"caller is not admin\");\n    ///     self.storage.user_authorization.at(user).schedule_value_change(true);\n    /// }\n    /// ```\n    ///\n    /// ## Cost\n    ///\n    /// The `SSTORE` AVM opcode is invoked `2 * N + 2` times, where `N` is `T`'s packed length.\n    pub fn schedule_value_change(self, new_value: T)\n    where\n        T: Packable,\n    {\n        let _ = self.schedule_and_get_value_change(new_value);\n    }\n\n    /// Schedules a write to the current value, returning the scheduled entry.\n    pub fn schedule_and_get_value_change(self, new_value: T) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        let mut value_change = self.read_value_change();\n        let delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n        let current_delay = delay_change.get_current(current_timestamp);\n\n        // TODO: make this configurable https://github.com/AztecProtocol/aztec-packages/issues/5501\n        let timestamp_of_change = current_timestamp + current_delay;\n        value_change.schedule_change(new_value, current_timestamp, current_delay, timestamp_of_change);\n\n        self.write(value_change, delay_change);\n\n        value_change\n    }\n\n    /// Schedules a write to the current delay.\n    ///\n    /// This works just like [`schedule_value_change`](DelayedPublicMutable::schedule_value_change), except instead of\n    /// changing the value in the state variable, it changes the delay that will govern future invocations of that\n    /// function.\n    ///\n    /// The current delay does not immediately change. Once the current delay passes,\n    /// [`get_current_delay`](DelayedPublicMutable::get_current_delay) automatically begins to return `new_delay`, and\n    /// [`schedule_value_change`](DelayedPublicMutable::schedule_value_change) begins using it.\n    ///\n    /// ## Multiple Scheduled Changes\n    ///\n    /// Only a **single** delay can be scheduled to become the new delay at a given point in time. Any prior scheduled\n    /// changes which have not yet become current are **replaced** with the new one and discarded.\n    ///\n    /// To illustrate this, consider a scenario at `t0` with a current delay `A`. A delay change to `B` is scheduled to\n    /// occur at `t1`. At some point _before_ `t1`, a second delay change to `C` is scheduled to occur at `t2` (`t2 >\n    /// t1`). The result is that the current delay continues to be `A` all the way until `t2`, at which point it\n    /// changes to `C`.\n    ///\n    /// ## Delays When Changing Delays\n    ///\n    /// A delay change cannot always be immediate: if it were, then it'd be possible to break `DelayedPublicMutable`'s\n    /// invariants by setting the delay to a very low or zero value and then scheduling a value change, resulting in a\n    /// new value becoming the current one earlier than was predictable based on the prior delay. This would prohibit\n    /// private reads, which is the reason for existence of this state variable.\n    ///\n    /// Instead, delay changes are themselves scheduled and delay so that the property mentioned above is preserved.\n    /// This results in delay increases and decreases being asymmetrical.\n    ///\n    /// If the delay is being decreased, then this requires a delay equal to the difference between the current and new\n    /// delay, so that a scheduled value change that occurred as the new delay came into effect would be scheduled for\n    /// the same timestamp as if no delay change had occurred.\n    ///\n    /// If the delay is being increased, then the new delay becomes effective immediately, as new value changes would\n    /// be scheduled for a timestamp that is further than the current delay.\n    ///\n    /// ## Examples\n    ///\n    /// A public setter that sets the pause delay:\n    /// ```noir\n    /// #[public]\n    /// fn set_pause_delay(delay: u64) {\n    ///     assert_eq(self.storage.admin.read(), self.msg_sender(), \"caller is not admin\");\n    ///     self.storage.paused.schedule_delay_change(delay);\n    /// }\n    /// ```\n    ///\n    /// ## Cost\n    ///\n    /// The `SSTORE` AVM opcode is invoked `2 * N + 2` times, where `N` is `T`'s packed length.\n    pub fn schedule_delay_change(self, new_delay: u64)\n    where\n        T: Packable,\n    {\n        let mut delay_change = self.read_delay_change();\n\n        let current_timestamp = self.context.timestamp();\n\n        delay_change.schedule_change(new_delay, current_timestamp);\n\n        // We can't just update the `ScheduledDelayChange`, we need to update the entire storage because we need to\n        // also recompute and write the hash.\n        // We _could_ just read everything, update the hash and `ScheduledDelayChange` but not overwrite the\n        // `ScheduledValueChange`, resulting in fewer storage writes, but that would require careful handling of\n        // storage slots and `WithHash`'s internal layout, which is not worth doing at this point.\n        self.write(self.read_value_change(), delay_change);\n    }\n\n    /// Returns the current value.\n    ///\n    /// If [`schedule_value_change`](DelayedPublicMutable::schedule_value_change) has never been called, then this\n    /// returns the default empty public storage value, which is all zeroes - equivalent to `let t =\n    /// T::unpack(std::mem::zeroed());`.\n    ///\n    /// It is not possible to detect if a `DelayedPublicMutable` has ever been initialized or not other than by testing\n    /// for the zero sentinel value. For a more robust solution, store an `Option<T>` in the `DelayedPublicMutable`.\n    ///\n    /// Use [`get_scheduled_value`](DelayedPublicMutable::get_scheduled_value) to instead get the last value that was\n    /// scheduled to become the current one (which will equal the current value if the delay has already passed).\n    ///\n    /// ## Examples\n    ///\n    /// A public getter that returns a user's authorization status:\n    /// ```noir\n    /// #[external(\"public\")]\n    /// fn is_authorized(user: AztecAddress) -> bool {\n    ///     self.storage.user_authorization.at(user).get_current_value()\n    /// }\n    /// ```\n    ///\n    /// ## Cost\n    ///\n    /// The `SLOAD` AVM opcode is invoked `2 * N + 1` times, where `N` is `T`'s packed length.\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        let value_change = self.read_value_change();\n\n        value_change.get_current_at(current_timestamp)\n    }\n\n    /// Returns the current delay.\n    ///\n    /// This is the delay that would be used by [`schedule_value_change`](DelayedPublicMutable::schedule_value_change)\n    /// if it were called in the current transaction.\n    ///\n    /// If [`schedule_delay_change`](DelayedPublicMutable::schedule_delay_change) has never been called, then this\n    /// returns the `InitialDelay` used in the [`storage`](crate::macros::storage::storage) struct.\n    ///\n    /// Use [`get_scheduled_delay`](DelayedPublicMutable::get_scheduled_delay) to instead get the last delay that was\n    /// scheduled to become the current one (which will equal the current delay if the delay has already passed).\n    ///\n    /// ## Examples\n    ///\n    /// A public getter that returns the pause delay:\n    /// ```noir\n    /// #[external(\"public\")]\n    /// fn get_pause_delay() -> u64 {\n    ///     self.storage.paused.get_current_delay()\n    /// }\n    /// ```\n    ///\n    /// ## Cost\n    ///\n    /// The `SLOAD` AVM opcode is invoked a single time, regardless of `T`.\n    pub fn get_current_delay(self) -> u64\n    where\n        T: Packable,\n    {\n        let current_timestamp = self.context.timestamp();\n        self.read_delay_change().get_current(current_timestamp)\n    }\n\n    /// Returns the last scheduled value and timestamp of change.\n    pub fn get_scheduled_value(self) -> (T, u64)\n    where\n        T: Packable,\n    {\n        self.read_value_change().get_scheduled()\n    }\n\n    /// Returns the last scheduled delay and timestamp of change.\n    pub fn get_scheduled_delay(self) -> (u64, u64)\n    where\n        T: Packable,\n    {\n        self.read_delay_change().get_scheduled()\n    }\n\n    fn read_value_change(self) -> ScheduledValueChange<T>\n    where\n        T: Packable,\n    {\n        // We don't read ScheduledValueChange directly by having it implement Packable because ScheduledValueChange and\n        // ScheduledDelayChange are packed together (sdc and svc.timestamp_of_change are stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_value_change::<T, <T as Packable>::N>(packed)\n    }\n\n    fn read_delay_change(self) -> ScheduledDelayChange<InitialDelay>\n    where\n        T: Packable,\n    {\n        // Since all ScheduledDelayChange member are packed into a single field, we can read a single storage slot here\n        // and skip the ones that correspond to ScheduledValueChange members. We are abusing the fact that the field\n        // containing the ScheduledDelayChange data is the first one in the storage layout - otherwise we'd need to\n        // offset the storage slot to get the position where it'd land. We don't read ScheduledDelayChange directly by\n        // having it implement Packable because ScheduledValueChange and ScheduledDelayChange are packed together (sdc\n        // and svc.timestamp_of_change are stored in the same slot).\n        let packed = self.context.storage_read(self.storage_slot);\n        unpack_delay_change::<InitialDelay>(packed)\n    }\n\n    fn write(self, value_change: ScheduledValueChange<T>, delay_change: ScheduledDelayChange<InitialDelay>)\n    where\n        T: Packable,\n    {\n        // Whenever we write to public storage, we write both the value change and delay change to storage at once. We\n        // do so by wrapping them in a single struct (`DelayedPublicMutableValues`). Then we wrap the resulting struct\n        // in `WithHash`. Wrapping in `WithHash` makes for more costly writes but it also makes private proofs much\n        // simpler because they only need to produce a historical proof for the hash, which results in a single\n        // inclusion proof (as opposed to 4 in the best case scenario in which T is a single field). Private delayed\n        // public mutable reads are assumed to be much more frequent than public writes, so this tradeoff makes sense.\n        let values = WithHash::new(DelayedPublicMutableValues::new(value_change, delay_change));\n\n        self.context.storage_write(self.storage_slot, values);\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, &mut PrivateContext>\nwhere\n    T: Eq,\n{\n    /// Returns the current value.\n    ///\n    /// If [`schedule_value_change`](DelayedPublicMutable::schedule_value_change) has never been called, then this\n    /// returns the default empty public storage value, which is all zeroes - equivalent to `let t =\n    /// T::unpack(std::mem::zeroed());`.\n    ///\n    /// It is not possible to detect if a `DelayedPublicMutable` has ever been initialized or not other than by testing\n    /// for the zero sentinel value. For a more robust solution, store an `Option<T>` in the `DelayedPublicMutable`.\n    ///\n    /// ## Privacy\n    ///\n    /// This function does leak some privacy, though in a subtle way. Understanding this is key to understanding how to\n    /// use `DelayedPublicMutable` in a privacy-preserving way.\n    ///\n    /// Private reads are based on a historical public storage read at the anchor block (i.e.\n    /// [`crate::history::storage::public_storage_historical_read`]). `DelayedPublicMutable` is able to provide\n    /// guarantees about values read in the past remaining the state variable's current value into the future due to\n    /// the existence of delays when scheduling writes. It then sets the `expiration_timestamp` property of the current\n    /// transaction (see\n    /// [`PrivateContext::set_expiration_timestamp`](crate::context::PrivateContext::set_expiration_timestamp)) to\n    /// ensure that the transaction can only be included in a block **prior** to the state variable's value changing.\n    /// In other words, it knows some facts about the near future up until some time horizon, and then makes sure that\n    /// it doesn't act on this knowledge past said moment.\n    ///\n    /// Because the `expiration_timestamp` property is part of the transaction's public information, any mutation to\n    /// this value could result in transaction fingerprinting. Note that multiple contracts may set this value during a\n    /// transaction: it is the smallest (most restrictive) timestamp that will be used.\n    ///\n    /// If the state variable **does not** have any value changes scheduled, then the timestamp will be set to that of\n    /// the anchor block plus the current delay. If multiple contracts use the same delay for their\n    /// `DelayedPublicMutable` state variables, then these will all be in the same privacy set.\n    ///\n    /// If the state variable **does** have a value change scheduled, then the timestamp will be set to equal the time\n    /// at which the current value will change, i.e. the one\n    /// [`get_scheduled_value`](DelayedPublicMutable::get_scheduled_value) returns - which is public information. This\n    /// results in an unavoidable privacy leak of any transactions in which a contract privately reads a\n    /// `DelayedPublicMutable` that will change soon.\n    ///\n    /// Transactions that do not read from a `DelayedPublicMutable` are part of a privacy set in which the\n    /// `expiration_timestamp` is set to their anchor block plus [`crate::protocol::constants::MAX_TX_LIFETIME`],\n    /// making this the most privacy-preserving delay. The less frequent said value changes are, the more private the\n    /// contract is. Wallets can also then choose to further lower this timestamp to make it less obvious that their\n    /// transactions are interacting with this soon-to-change variable.\n    ///\n    /// ## Examples\n    ///\n    /// A private action that requires authorization:\n    /// ```noir\n    /// #[external(\"private\")]\n    /// fn do_action() {\n    ///     assert(\n    ///         self.storage.user_authorization.at(self.msg_sender()).get_current_value(),\n    ///         \"caller is not authorized\"\n    ///     );\n    ///\n    ///     // do the action\n    /// }\n    /// ```\n    ///\n    /// A private action that can be paused:\n    /// ```noir\n    /// #[external(\"private\")]\n    /// fn do_action() {\n    ///     assert(!self.storage.paused.get_current_value(), \"contract is paused\");\n    ///\n    ///     // do the action\n    /// }\n    /// ```\n    ///\n    /// ## Cost\n    ///\n    /// This function performs a single merkle tree inclusion proof, which is in the order of 4k gates.\n    pub fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        // When reading the current value in private we construct a historical state proof for the public value.\n        // However, since this value might change, we must constrain the maximum transaction timestamp as this proof\n        // will only be valid for the time we can ensure the value will not change, which will depend on the current\n        // delay and any scheduled delay changes.\n        let (value_change, delay_change, anchor_timestamp) = self.anchor_read_from_public_storage();\n\n        // We use the effective minimum delay as opposed to the current delay at the anchor block's timestamp as this\n        // one also takes into consideration any scheduled delay changes. For example, consider a scenario in which at\n        // timestamp `x` the current delay was 86400 seconds (1 day). We may naively think that the earliest we could\n        // change the value would be at timestamp `x + 86400` by scheduling immediately after the anchor block's\n        // timestamp, i.e. at timestamp `x + 1`. But if there was a delay change scheduled for timestamp `y` to reduce\n        // the delay to 43200 seconds (12 hours), then if a value change was scheduled at timestamp `y` it would go\n        // into effect at timestamp `y + 43200`, which is earlier than what we'd expect if we only considered the\n        // current delay.\n        let effective_minimum_delay = delay_change.get_effective_minimum_delay_at(anchor_timestamp);\n        let time_horizon = value_change.get_time_horizon(anchor_timestamp, effective_minimum_delay);\n\n        // We prevent this transaction from being included in any timestamp after the time horizon, ensuring that the\n        // historical public value matches the current one, since it can only change after the horizon.\n        self.context.set_expiration_timestamp(time_horizon);\n\n        value_change.get_current_at(anchor_timestamp)\n    }\n\n    fn anchor_read_from_public_storage(self) -> (ScheduledValueChange<T>, ScheduledDelayChange<InitialDelay>, u64)\n    where\n        T: Packable,\n    {\n        let header = self.context.get_anchor_block_header();\n        let address = self.context.this_address();\n\n        let anchor_timestamp = header.global_variables.timestamp;\n\n        let values: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::historical_public_storage_read(header, address, self.storage_slot);\n\n        (values.svc, values.sdc, anchor_timestamp)\n    }\n}\n\nimpl<T, let InitialDelay: u64> DelayedPublicMutable<T, InitialDelay, UtilityContext>\nwhere\n    T: Eq,\n{\n    pub unconstrained fn get_current_value(self) -> T\n    where\n        T: Packable,\n    {\n        let dpmv: DelayedPublicMutableValues<T, InitialDelay> =\n            WithHash::utility_public_storage_read(self.context, self.storage_slot);\n\n        let current_timestamp = self.context.timestamp();\n        dpmv.svc.get_current_at(current_timestamp)\n    }\n}\n"
     },
-    "84": {
+    "85": {
       "function_locations": [
         {
           "name": "<impl StateVariable<1, Context> for Map<K, V, Context>>::new",
@@ -2943,10 +2955,10 @@
           "start": 1189
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/map.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/state_vars/map.nr",
       "source": "use crate::protocol::{storage::map::derive_storage_slot_in_map, traits::ToField};\nuse crate::state_vars::StateVariable;\n\n/// A key-value container for state variables.\n///\n/// A key-value storage container that maps keys to state variables, similar to Solidity mappings.\npub struct Map<K, V, Context> {\n    pub context: Context,\n    storage_slot: Field,\n}\n\n// Map reserves a single storage slot regardless of what it stores because nothing is stored at said slot: it is only\n// used to derive the storage slots of nested state variables.\nimpl<K, V, Context> StateVariable<1, Context> for Map<K, V, Context> {\n    fn new(context: Context, storage_slot: Field) -> Self {\n        assert(storage_slot != 0, \"Storage slot 0 not allowed. Storage slots must start from 1.\");\n        Map { context, storage_slot }\n    }\n\n    fn get_storage_slot(self) -> Field {\n        self.storage_slot\n    }\n}\n\nimpl<K, V, Context> Map<K, V, Context> {\n    /// Returns the state variable associated with the given key.\n    ///\n    /// This is equivalent to accessing `mapping[key]` in Solidity.\n    pub fn at<let N: u32>(self, key: K) -> V\n    where\n        K: ToField,\n        V: StateVariable<N, Context>,\n    {\n        V::new(\n            self.context,\n            derive_storage_slot_in_map(self.storage_slot, key),\n        )\n    }\n}\n"
     },
-    "90": {
+    "91": {
       "function_locations": [
         {
           "name": "WithHash<T, M>::new",
@@ -2981,7 +2993,7 @@
           "start": 3571
         }
       ],
-      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/utils/with_hash.nr",
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/fnd/noir-contracts/contracts/protocol/aztec_sublib/src/utils/with_hash.nr",
       "source": "use crate::{\n    context::{PublicContext, UtilityContext},\n    history::storage::public_storage_historical_read,\n    oracle,\n};\nuse crate::protocol::{\n    abis::block_header::BlockHeader, address::AztecAddress, hash::poseidon2_hash, traits::Packable,\n};\n\n/// A struct that allows for efficient reading of value `T` from public storage in private.\n///\n/// The efficient reads are achieved by verifying large values through a single hash check and then proving inclusion\n/// only of the hash in public storage. This reduces the number of required tree inclusion proofs from `M` to 1.\n///\n/// # Type Parameters\n/// - `T`: The underlying type being wrapped, must implement `Packable<N>`\n/// - `M`: The number of field elements required to pack values of type `T`\npub struct WithHash<T, let M: u32> {\n    value: T,\n    packed: [Field; M],\n    hash: Field,\n}\n\nimpl<T, let M: u32> WithHash<T, M>\nwhere\n    T: Packable<N = M> + Eq,\n{\n    pub fn new(value: T) -> Self {\n        let packed = value.pack();\n        Self { value, packed, hash: poseidon2_hash(packed) }\n    }\n\n    pub fn get_value(self) -> T {\n        self.value\n    }\n\n    pub fn get_hash(self) -> Field {\n        self.hash\n    }\n\n    /// Reads the value stored in this [WithHash] from public storage.\n    pub fn public_storage_read(context: PublicContext, storage_slot: Field) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub unconstrained fn utility_public_storage_read(\n        context: UtilityContext,\n        storage_slot: Field,\n    ) -> T {\n        context.storage_read(storage_slot)\n    }\n\n    pub fn historical_public_storage_read(\n        header_to_read_from: BlockHeader,\n        address: AztecAddress,\n        storage_slot: Field,\n    ) -> T {\n        // We could simply produce historical inclusion proofs for each field in `packed`, but that would require one\n        // full sibling path per storage slot. Instead, we get an oracle to provide us the values, and instead we prove\n        // inclusion of their hash, which is both a much smaller proof (a single slot), and also independent of the\n        // size of T.\n        let hint = WithHash::new(\n            // Safety: We verify that a hash of the hint/packed data matches the stored hash.\n            unsafe { oracle::storage::storage_read(header_to_read_from, address, storage_slot) },\n        );\n\n        // The actual `value` (of type T, of packed length M fields) is stored in contiguous fields from the\n        // `storage_slot`. The _hash_ of the `value` is stored at the end, at slot: `storage_slot + M`.\n        let hash =\n            public_storage_historical_read(header_to_read_from, storage_slot + M as Field, address);\n\n        if hash != 0 {\n            assert_eq(hash, hint.get_hash(), \"Hint values do not match hash\");\n        } else {\n            // The hash slot can only hold a zero if it is uninitialized. Therefore, the hints must then be zero (i.e.\n            // the default value for public storage) as well.\n            assert_eq(\n                hint.get_value(),\n                T::unpack(std::mem::zeroed()),\n                \"Non-zero hint for zero hash\",\n            );\n        };\n\n        hint.get_value()\n    }\n}\n\nimpl<T, let M: u32> Packable for WithHash<T, M>\nwhere\n    T: Packable<N = M>,\n{\n    let N: u32 = M + 1;\n\n    fn pack(self) -> [Field; Self::N] {\n        let mut result: [Field; Self::N] = std::mem::zeroed();\n        for i in 0..M {\n            result[i] = self.packed[i];\n        }\n        result[M] = self.hash;\n\n        result\n    }\n\n    fn unpack(packed: [Field; Self::N]) -> Self {\n        let mut value_packed = [0; M];\n        for i in 0..M {\n            value_packed[i] = packed[i];\n        }\n        let hash = packed[M];\n\n        Self { value: T::unpack(value_packed), packed: value_packed, hash }\n    }\n}\n"
     }
   },
@@ -3008,12 +3020,12 @@
           "visibility": "public"
         }
       },
-      "bytecode": "JwACBAEoAAABBIBEJwAABEQnAgIEACcCAwQAHwoAAgADAEMlAAAAPC0CAkMnAgMEQycCBAQBOw4ABAADHgIAAwknAgQBASQCAAMAAABTJQAAAngeAgADASkCAAQA71JTTScCBQABKwIABgAAAAAAAAAAAwAAAAAAAAAALQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0OBAkAIgkCCS0OBQkAIgkCCS0OAwkAIgkCCS0OBgktCAEDJwIEBAUACAEEAScDAwQBACIHAgQAIgMCBT8PAAQABScCBAQBACoDBAUtCwUFJwIDAAAKKgUDBCcCAwEACioEAwYkAgAGAAABCCUAAAKKHgIAAwYeAgAEAC8qAAUABAAGHAoGBQQcCgUEAAIqBgQFLAIABAAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBQQGHAoGBwQcCgcFAAIqBgUHBCoHBAYcCgYIAhwKCAcAHAoHCAIcCggJARwKCQcCJwIIAgAKKgcICRYKCQccCgcKAAIqBgoLLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCwYKHAoKDAQcCgwLAAIqCgsMBCoMBAocCgoMAhwKDAQAHAoEDAIcCgwNARwKDQQCCioECAwWCgwEHAoECAACKgoIDQQqDQYIHAoICgQcCgoGABwKBggFHAoMBgUcCgQKBQQqCggEHAoLCAUcCgkKBRwKBwkFBCoJCAccCgUIBQwqAwgFKQIAAwUAAVGAJAIABQAAAmgjAAACWQQqCgMEACoHBAIjAAACdwQqBgMFACoEBQIjAAACdyYqAQABBU/fSorXz/DTPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
+      "bytecode": "JwACBAEoAAABBIBEJwAABEQnAgIEACcCAwQAHwoAAgADAEMlAAAAPC0CAkMnAgMEQycCBAQBOw4ABAADHgIAAwknAgQBASQCAAMAAABTJQAAAngeAgADASkCAAQA71JTTScCBQABKwIABgAAAAAAAAAAAwAAAAAAAAAALQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0OBAkAIgkCCS0OBQkAIgkCCS0OAwkAIgkCCS0OBgktCAEDJwIEBAUACAEEAScDAwQBACIHAgQAIgMCBT8PAAQABScCBAQBACoDBAUtCwUFJwIDAAAKKgUDBCcCAwEACioEAwYkAgAGAAABCCUAAAKKHgIAAwYeAgAEAC8qAAUABAAGHAoGBQQcCgUEAAIqBgQFLAIABAAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBQQGHAoGBwQcCgcFAAIqBgUHBCoHBAYcCgYIAhwKCAcAHAoHCAIcCggJARwKCQcCJwIIAgAKKgcICRYKCQccCgcKAAIqBgoLLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCwYKHAoKDAQcCgwLAAIqCgsMBCoMBAocCgoMAhwKDAQAHAoEDAIcCgwNARwKDQQCCioECAwWCgwEHAoECAACKgoIDQQqDQYIHAoICgQcCgoGABwKBggFHAoMBgUcCgQKBQQqCggEHAoLCAUcCgkKBRwKBwkFBCoJCAccCgUIBQwqAwgFKQIAAwUAAVGAJAIABQAAAlkjAAACaAQqBgMFACoEBQIjAAACdwQqCgMEACoHBAIjAAACdyYqAQABBU/fSorXz/DTPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
       "custom_attributes": [
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rVhbbtswELyLvv1B7oOPXKUoAidRCgOGE7h2gSLw3bsbcym5ANmE6Y81Hlmj4XK4lPU2Pc0P5x/3u8Pzy8/p7tvb9HDc7fe7H/f7l8ftafdyEPZtcvoR5BM3U+DpjjZTdNdDej8knO6CHOSbl9/keD16BwUAGrBTaKfQGDKGjGFvgAtQE1dABnIB0W4RiwufVJAVhAKyN1AYcN6AMd4YrzZkVABgwBjU3yQFoQBSJisIBbAxnAtQz4AKhAFlojDoBahV1FMpFpCVIQXKiB9EMiCXo9hAIgPKRAGsTFKgjNwC9aZXYIzelJyCXEBSxivIBWRjsk4wbCZyUl5CBcqIMSIugDULrIAL0GmioEAZMUbveUkKuIBkTFJGjFF2BoRhMcbOGRA/7BWIQxY/7JVBBcqIDQYyoIzYYK3YFRhDxmjFWByyVuwKjAnGaMVYzLNWjPPlsplsWdyfjvOsq2K1TmT1vG6P8+E03R3O+/1m+rXdn99/9PN1e3g/nrZHOSsDmg9PchTB591+VnTZLFe79qVe4hDK5YJzqhLsbzR8WyMH74tEDgiLQrxRgI4Ll6oJ73JViJ8ZR8gmgS641jh6Guih2kCPuaXBbQ0kcyELZWQc6HJcPAC3PMReLXTN2JQuColuFFJbAZJFCleJkE52I5A7kUBnFjLSEgnppbep6pQiO20PVw2XXVvD96bDJDCtBoJ/KXSiKV3bMgE+0ZgGoNkACB0f1NYgH21OCFxcVePDNjBHX6c15qaNXrR8Xq+yVrR8RyICmESUzW2RwM9IgEmghLIh8fFlxs22Bz2RQGQFFRywZQQ6CU2ytxWNRDE0m2dnXkOdk+hjq+f8YyCRl4Hk2BxIJ6DydOSSiSRJfFOEexsBYG3BDjg26xE6jSMvc+ucp6ZGJ2JBHv+KRvCpbaPXRKOVA3JzK+iPg2EZB6SWCexMLTLXNR8cNG30JzZUH0kae2tisdcCM3CtBqZV+3Kf0KhLBWVeBzW4btDO85CGlKDW1AU/qFFXnHQwHNWgqgFxTMNzrBohjGqEqhH9f9AY9ZGrBsCoj+y+rpFqxgBpTANCzRiM1hRSzRj6UR+pZgxhbN0iLhnD0Yzhkg8crceNxqiPJWPyHDaq4b6usWSMcLB/0NILKeQxjUi2N0hJYUwjrf5uDPZ1+Z9iGSPn273w449B3H6w5N6u71x91ne0NiIa3+Xr9nF3vHkbdlGx4277sJ/L1+fz4XF19vT71c7Y27TX48vj/HQ+zqq0vFLTV03fvPwhki3l+0Xv9wc=",
+      "debug_symbols": "rVjbbuM4DP0XP+dBvOnSXxkMirRNBwGCtMi0CyyK/vuSiSgnC0jbavYlPjm2jw8pipL9sTztHt5/3e+Pzy+/l7sfH8vDaX847H/dH14et2/7l6OyH0uwn6i/tFmiLHe8WVK4HPL5kGm5i3rQf6DXlHQ5QsAKkBz4KfJT5Aw7w84IOJAKzMQFsINSQfJHpOoCsgmKgVhBAQeVwQAOnAFnwGxoVIjowBmya7KBWAEbUwzECsQZKRWYZyQDyqAxSRkCBWaV7FROFRRj2IAx6oeIHejtpDaI2YExSYEYkw0Yo48ge+gFOGMP5WCgVJCNAQOlguJMsQHGzcJB08tkwBg1xiwViNWCGJAKbJg4GjBGjfG5XrIBqSA7k41RY1yCA2VEjUkIDtSPgAF1KOpHwBgyYIzaEGQHxqgNsYxdgDPsjGVM1KFYxi7AmeiMZUzUvFjGpHx+bhafFvdvp93OZsXVPNHZ87o97Y5vy93x/XDYLH9tD+/ni36/bo/n49v2pGc1oN3xSY8q+Lw/7Ax9bta7Q/9WIEhcb1dcYpMQvNGAvkaJAFWiRMJVId8o4MBFyNFNQChNIcE34oipxYH66E4cQw3CNRdEqachfQ2yejsr6ESZigOLrB6Qeh7SQAO5SahaU8hyo5D7Cpi9pHS+tvsRbi2UQUlQcAuFeC0JSOW2qgapKMHaw0UjlNDXgNFwuATlq0DoXwqD0tSu7aWJkHlOA8ltIMaBDx5EUlKuGhxArrLxZRsqAW1YU+naGJUWlNKqM8ReacFAIiG6RNLFbZXg70igSxBAT+Lr00y6bQ9HIpHZE6o4Us8IDio069pWNTKn2G2eg3GNbUwSpF7P+Y9AkqyBlNQNZFCgujsKXqGKqZ8NGS0ESG0lCCipm484aByltKUgBOCuxqDEom7/qkaE3LcxaqJtwmLpLgXjOATXODD3TNBgaEmkzfkYsGtjPLCx+cja2HsDS6MWWFBaNihftS/4hkabKqTjOqkhbYG+baNf19AUtJyGCJMabcZpB6NZDW4amOY0QFLTiHFWIzaNBP+DxqyP0jQQZ32U8OcaudUYEs9pYGw1hrM5xdxqjGDWR241Rjg3b3V9bTVGszVGa33QbD5uNGZ9rDXGGGY1wp9rrDXGNNk/eO2FHMucRmJfGzSlOKeRr143Jvu6vqekdXvc74Vf3wZJf2Mpo1U/hLbXD3xtRDV+6t/t4/508zXs08RO++3DYVf/Pr8fH6/Ovv396mf8a9rr6eVx9/R+2pnS+knNPjX9AH0h0iXl56c97x8=",
       "is_unconstrained": true,
       "name": "get_update_delay"
     },
@@ -3077,11 +3089,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"
     },
@@ -4974,14 +4986,14 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "H4sIAAAAAAAA/+2dd3hUxduG875DVSmCiA3EgvRqwy6E0KRJsxNDssBqSOImQUFRYkdFkw0WbChdEETAgoKiIorMQ1URpUizF+xdvgMh2U3ZZDbJc3ldv+vzH4fNu/c7Z87MOVPCjQnmPLQ0LXNYsj99ZPzw1ED8gXJivO8GX2Jmhj81ZYt5NmtBl+SExGu7pN7QLTMlMTYhOTlrxoDOfbvHBbNmXeLPSPGlp2sThyAjDkGHu5DqX+gQdKQd7xDV0CnqOJdaNXIJauwSdLxLUBOnmp/gFHWiU9RJTlEnu1S+g2TN7RLwJyf7R+z/+aSY7Ozc7OwVTWJK/0+y5nROT/cFMi73BVJzs3OCK5q0T+ob2NHhqRYv9497MSvr0quan/pFjzFL0nJid/ySu9f7CsyY0rEftNl1bXmwYyNia+UXSmiIxf1T033+pNSUjv19gVGZGQn7B1lwUkHDeNUtKJ9SUGoW9vOxk2BuhLkJZhzMzYVrnhssuwmbO8R4GZza4JYyUTHRV7CFUwVvcqrgeEYFWzpVcJxTBbMcKlieXnRLWHl8WDkrrHyz15NuhbkN5naYO6Jvh1ZO7XCrUzvcybhRrZ0qeJtTBe9iVLCNUwVvd6rg3aSedGdY+a6w8t1h5Tu8njQB5h6Ye2Hui74d2jq1wwSndpjIuFHtnCp4j1MF72dUsL1TBe91quADpJ40Max8f1j5gbDyfV5PyobJgQnC5EbfDh2c2iHbqR0mkdohvJwTVg6GlXO9dngQ5iGYh2EeKdwOQYdrPNnpCic7zLjKnsx5nCbR17C+Uw0fLQMkF493quGjF5ZnjvdY6dnNqAG3lAf7OGei+0RErMkvlKu/PhZWfrzEOekTXm99EmYKzFMwTxee2kswa+ZAf8qIZF/edZR15c0cRl0B0GHJkLM/elRasg9mqtsaw6U/TZXoe7w3Tpzu47RKquO0JoXvRLWc6O5ETFSNOz36BVxOrkMlPLJb4053ippR9h0oTx1n5LhmLyMo+uwdPGyuQ8fq4NT5ZjhFzYz2CRastHf3zChvoOPDc1bpuacv2LS8PNjZEbFV8wvleibPKmGXoHnYz2d7T+RnYObAzIW3hVeOHj3TbdQ949QM8/67jYI5ThWcT5rrzQsrzw8rzw0rP+vdq+dgFsA8D7OwPL1sUem1Hzds99hy1X5RiW/754q8+RfDvADzIsxLFXvftCr7HoS9b17mvG9aeWS3Z/kSwpvEy74k26ErVqidW0fVzq9w2rm1R3Zr51cJ7exlfzU7ymeS0/1r5TZglxJyt27tlntZOXKXTV3itahb/tc4o3apW/bXSw/6ft++vYWyB3Nd+ugy77Kcmuk1rwaMjpd3A6IlO75elpeOxZsJU8r1elleUG5VUGpd5OXyBsybMG/BrChPzd8uveZtL6ndqzzYlRGx1QvauTwN8nZBuWXYp2+ElVd6TfIOzLswq2DeY+04v+PUCqsZkzq3reB3nSpo/7ut4FVOFQRp1rk6rGzDyggrv+f1pDUwa2HWwaxn7TivcWqHDaR22BBWXhtWXhdWXu+1w0aY92E+gPmwPE+DTaXX/uchP+woV+03hZU3hpUXF3lEfgSzGeZjmE8Kzws1ynmhRyr7PgRDM8MtoeLWcpze57pVyekWbCkedWWRKI+1NdqZtQmWutVYNEO0zb0lqon4tsrbvdxWwq1wa+Si6Yrm99hOrO1ltmaM05Vst+PLcylbnaLcLuXT4pdS9EtOl/Jpib9eM79PZnKGf2BiQnJCwCtOCmbNjk1NSc9ISMlw6AzFY3Vt/aGZ1aZfldimWa24H46qN+m2C1ZMvPWCZq3Dq7IlrLw1moTeod0OmJ0lXMeCuFHDfElJvqTYzMBoX+ekpEnhCXeElXcGS5wWRleLXTC7C4/lKlE/DXeVPTzL81tLbvtq05z63p5KeiDsKXJUUDU3mjOWalkzOgcCCWO2xDRyCY91CUp1CUpxCcpwCQq4BCW4BCVWWp16VloTpFdanRIqrU5O7eTU/fq7BGW6BA1zCUp2CfJX2m0ZWWntlOQSdLZLUBOXoBtdgsYdfHRMORDcsPe159VZ37357r+HDvxt4bC5k07vNmtH053fDp2y7dy9i3a2q8Qnt0vl1C3fKS7ZKuno2w3UvLJALSoL1LKyQK0qC9S6skBtKgvUtrJA7SoL1N4B5LY7OTPGYW+SN5va4zSb+qySZlOflfDrUGVlj3G4jo7R7me5JBaHxKcyEqtD4tMYiY1D4tPLk7gs6BlOvfDB8mzil5X6TEZDVnFI3ImRuKpD4rMYias5JD6bkbi6Q+JzGIlrOCQ+l5G4pkPi8xiJD3FIfD4j8aEOiS9gJD7MIfGFjMS1HBJ3ZiSu7ZC4CyNxHYfEsYzEdR0Sd2UkPtwhcRwjcT2HxN0Yies7JO7OSHyEQ+IejMQNHBL3ZCQ+0iFxL0bihg6JL2IkPsohcW9G4qMdEvdhJD7GIXFfRuJjHRL3YyQ+ziFxf0biRg6JL2YkbuyQeAAj8fEOiQcyEjdxSDyIkfgEh8SDGYlPdEg8hJH4JIfElzAW3ZcyoJcxdiYud9qZeJRxd052qN4VjGu+spL2BMtxD69iQIcyoPEM6NUMaAIDOowBTWRAkxhQHwM6nAEdwYCOZED9DOg1DOi1DGgyAzqKAU1hQFMZ0DQG9DoGNMCApjOgGQxoJgM6mgG9ngG9gQEdw4COZUBvZEBvYkDHMaA3M6C3MKB2PIWaRaHeSqHeRqHeTqHeQaHeSaHeRaHeTaFOoFDvoVDvpVDvo1AnUqj3U6gPREkNOvwt2Gb7TTxl5z6gFJrqspNj3XxeTzJ2kazb3xGbTMkddMo9ldIzcinUSRQq5Veq7EMU6sMU6iMU6mQK9VEK9TEK9XEK9QkK9UkKdQqF+hSF+jSFynm+TqNQp1OoMyjUmRTqLAp1NoX6DIU6h0KdS6E+S6HOo1DnU6jPUagLKNTnKdSFFOoiCnUxhfoChfoihfoShfoyhbqEQn2FQn2VQl1KoS6jUF+jUF+nUJeXx1JaJvUNSl3fpFDfolBXUKhvU6grKdR3KNR3KdRVFOp7FOpqCtVSqKBQ11CoaynUdRTqegp1A4W6kUJ9n0L9gEL9kELdRKF+RKFuplA/plA/oVC3UKhbKdRtFOp2CvVTCnUHhbqTQt1Foe6mUPdQqJRffbefU6hfUKhfUqhfUahfU6jfUKjfUqjfUajfU6h7KdQfKNQfKdSfKNSfKdRfKNRfKdTfKNTfKdQ/KNQ/KdS/KNS/KdR/KNR/KdR9DCoc/vGycmGFg1UO1nCwVTjYqhxsNQ62Ogdbg4OtycEewsEeysEexsHW4mBrc7B1ONi6HOzhHGw9DrY+B3sEB9uAgz2Sg23IwR7FwR7NwR7DwR7LwR7HwTbiYBtzsMdzsE042BM42BM52JM42JM52KYc7CkcbDMOtjkH24KDbcnBtuJgW3OwbTjYthxsOw62PQfbgYPtyMGeysGexsGezsGewcGeycF24mDP4mDP5mDP4WDP5WDP42DP52Av4GAv5GA7c7BdONhYDrYrBxvHwXbjYLtzsD042J4cbC8O9iIOtjcH24eD7cvB9uNg+3OwF3OwAzjYgRzsIA52MAc7hIO9hIO9lIO9jIO9nIO9goO9koO9ioMdysHGc7BXc7AJHOwwDjaRg03iYH0c7HAOdgQHO5KD9XOw13Cw13KwyRzsKA42hYNN5WDTONjrONgAB5vOwWZwsJkc7GgO9noO9gYOdgwHO5aDvZGDvYmDHcfB3szB3sLBjudgszjYWznY2zjY2znYOzjYOznYuzjYuznYCRzsPRzsvRzsfRzsRA72fg72AQ42m4PN4WCDHGwuBzuJg32Qg32Ig32Yg32Eg53MwT7KwT7GwT7OwT7BwT7JwU7hYJ/iYJ/mYKdysNM42Okc7AwOdiYHO4uDnc3BPsPBzuFg53Kwz3Kw8zjY+RzscxzsAg72eQ52IQe7iINdzMG+wMG+yMG+xMG+zMEu4WBf4WBf5WCXcrDLONjXONjXOdjlHOwbHOybHOxbHOwKDvZtDnYlB/sOB/suB7uKg32Pg13NwVoOFhzsGg52LQe7joNdz8Fu4GA3crDvc7AfcLAfcrCbONiPONjNHOzHHOwnHOwWDnYrB7uNg93OwX7Kwe7gYHdysLs42N0c7B4O9jMO9nMO9gsO9ksO9isO9msO9hsO9lsO9jsO9nsOdi8H+wMH+yMH+xMH+zMH+wsH+ysH+xsHG7X4NuiE/SPo8i83k97Pf3Ku6S+nayKdGf/Nwf7Dwf7LwXJcuspx6SrHpascl65yXLrKcekqx6WrHJeucly6ynHpKselqxyXrnJcuspx6SrHpascl65yXLrKcekqx6Wr9ThYjktXOS5d5bh0lePSVY5LVzkuXeW4dJXj0lWOS1c5Ll3luHSV49JVjktXOS5d5bh0lePSVY5LVzkuXeW4dJXj0lWOS1c5Ll1twfi3q6Ecl65yXLrKcekqx6WrHJeucly6ynHpKselqx05WI5LVzkuXeW4dJXj0lWOS1c5Ll3luHSV49JVjktXOS5d5bh0lePSVY5LVzkuXeW4dJXj0tXYFU2Obrjr9PVXXxazceDnwyas+eX53H+ffuqR3InT9nRpOGRf70Ybih96lHmcceAgp+zkHOOuxpVew+/37dsX/TWd4pQ6aiuvS+pmTqm7M1I3d0rdg5G6hVPqnozULZ1S92KkbuWU+iJG6tZOqXszUrdxSt2HkbqtU+q+jNTtnFL3Y6Ru75Q6WvtxTm7Zmb2z7pluj3GOJFkHcLADy3zp/Fge7KDy3P2ysYOdfimB86uFylEpK0elrByVsnJUyspRKStHpawclbJyVMrKUSkrR6WsHJWyclTKylEpK0elrByVsnJUyspRKStHpawclbJyVMrKUSkrR6WsHJWyclTKylEpK0elrByVsnJUyhrgYDkqZeWolJWjUlaOSlk5KmXlqJSVo1JWjkpZOSpl5aiUlaNSVo5KWTkqZeWolJWjUlaOSlk5KmXlqJSVo1JWjkpZOSpl5aiUlaNSVo5KWTkqZeWolJWjUlaOSlk5KmXlqJSVo1LWIAfLUSkrR6WsHJWyclTKylEpK0elrByVsnJUyspRKStHpawclbJyVMrKUSkrR6WsHJWyclTKyvlrscpRKStHpawclbJyVMrKUSkrR6WsHJWyclTKylEpK0elrByVsnJUyspRKStHpawLOViOSlk5KmXlqJSVo1JWjkpZOSpl5aiUlaNSVo5KWTkqZeWolJWjUlaOSlk5KmXlqJSVo1JWjkpZOSpl5aiUlaNSVo5KWTkqZeWolJWjUlaOSlk5KmXlqJSVo1JWjkpZOSpl5aiUdQMHy1EpK0elrByVsnJUyspRKStHpawclbJyVMrKUSkrR6WsHJWyclTKylEpK0elrByVsnJUyspRNSpHpaykv+/AUSkrR6WsHJWyclTKylEpK0elrByVsnJUyspRKStHpawclbJyVMr6IwfLUSkrR6WsHJWyclTKylEp6+8c7B8c7J8c7F8cLEd/rBz9sXL0x8rRHxuO/thw9MeGoz82HP2x4eiPDUd/bDj6Y8PRHxuO/thw9MeGoz82HP2x4eiPDUd/bDj6Y8PRHxuO/thw9MemHgfL0R8bjv7YcPTHhqM/Nhz9seHojw1Hf2w4+mPD0R8bjv7YcPTHhqM/Nhz9seHojw1Hf2w4+mPD0R8bjv7YcPTHhqM/Nhz9seHoj00LDpajPzYc/bHh6I8NR39sOPpjw9EfG47+2HD0x6YjB8vRHxuO/thw9MeGoz82HP2x4eiPDUd/bDj6Y8PRHxuO/thw9MeGoz82HP2x4eiPDUd/bDj6YxPLwXLExiaOg+3GwXbnYHtwsD052F4c7EUcbG8Otg8H25eD7cfB9udgOZZcM4CDHcjBDuJgB3OwHP+t4fhvDcd/azj+W8Px3xqO/9Zw/LeG4781HP+t4fhvDcd/azj+W8Px3xqO/9Zw/LeG4781HP+t4fhvDcd/azj+W8Px3xqO/9Zw/LeG4781HP+t4fhvDcd/azj+WxPgYNMp/0ik4fhvDcd/azj+WxO1/9blH0Jp6pTayZHbxzcqNTCmZ4o/Izdmi+ne8dTTTj/jzE5nnX3Oueedf8GFnbvEdo3r1r1Hz14X9e7Tt1//iwcMHDR4yCWXXnb5FVdeNTT+6oRhiUm+4SNG+q+5NnlUSmradYH0jMzR198wZuyNN427+RY73mbZW+1t9nZ7h73T3mXvthPsPfZee5+daO+3D9hsm2ODNtdOsg/ah+zD9hE72T5qH7OP2yfsk3aKfco+bafaaXa6nWFn2ll2tn3GzrFz7bN2np1vn7ML7PN2oV1kF9sX7Iv2JfuyXWJfsa/apXaZfc2+bpfbN+yb9i27wr5tV9p37Lt2lX3PrrbWwq6xa+06u95usBvt+/YD+6HdZD+ym+3H9hO7xW612+x2+6ndYXfaXXa33WM/s5/bL+yX9iv7tf3Gfmu/s9/bvfYH+6P9yf5sf7G/2t/s7/YP+6f9y/5t/7H/2n2QGIhAFGIgVSBVIdUg1SE1IDUhh0AOhRwGqQWpDakDqQs5HFIPUh9yBKQB5EhIQ8hRkKMhx0COhRwHaQRpDDke0gRyAuREyEmQkyFNIadAmkGaQ1pAWkJaQVpD2kDaQtpB2kM6QDpCToWcBjkdcgbkTEgnyFmQsyHnQM6FnAc5H3IB5EJIZ0gXSCykKyQO0g3SHdID0hPSC3IRpDekD6QvpB+kP+RiyADIQMggyGDIEMglkEshl0Euh1wBuRJyFWQoJB5yNSQBMgySCEmC+CDDISMgIyF+yDWQayHJkFGQFEgqJA1yHSQASYdkQDIhoyHXQ26AjIGMhdwIuQkyDnIz5BbIeEgW5FbIbZDbIXdA7oTcBbkbMgFyD+ReyH2QiZD7IQ9AsiE5kCAkFzIJ8iDkIcjDkEcgkyGPQh6DPA55AvIkZArkKcjTkKmQaZDpkBmQmZBZkNmQZyBzIHMhz0LmQeZDnoMsgDwPWQhZBFkMeQHyIuQlyMuQJZBXIK9ClkKWQV6DvA5ZDnkD8ibkLcgKyNuQlZB3IO9CVkHeg6yGWAggayBrIesg6yEbIBsh70M+gHwI2QT5CLIZ8jHkE8gWyFbINsh2yKeQHZCdkF2Q3ZA9kM8gn0O+gHwJ+QryNeQbyLeQ7yDfQ/ZCfoD8CPkJ8jPkF8ivkN8gv0P+gPwJ+QvyN+QfyL+QfdAYqEAVaqBVoFWh1aDVoTWgNaGHQA+FHgatBa0NrQOtCz0cWg9aH3oEtAH0SGhD6FHQo6HHQI+FHgdtBG0MPR7aBHoC9EToSdCToU2hp0CbQZtDW0BbQltBW0PbQNtC20HbQztAO0JPhZ4GPR16BvRMaCfoWdCzoedAz4WeBz0fegH0QmhnaBdoLLQrNA7aDdod2gPaE9oLehG0N7QPtC+0H7Q/9GLoAOhA6CDoYOgQ6CXQS6GXQS+HXgG9EnoVdCg0Hno1NAE6DJoITYL6oMOhI6AjoX7oNdBrocnQUdAUaCo0DXodNABNh2ZAM6GjoddDb4COgY6F3gi9CToOejP0Fuh4aBb0Vuht0Nuhd0DvhN4FvRs6AXoP9F7ofdCJ0PuhD0CzoTnQIDQXOgn6IPQh6MPQR6CToY9CH4M+Dn0C+iR0CvQp6NPQqdBp0OnQGdCZ0FnQ2dBnoHOgc6HPQudB50Ofgy6APg9dCF0EXQx9Afoi9CXoy9Al0Fegr0KXQpdBX4O+Dl0OfQP6JvQt6Aro29CV0Heg70JXQd+DroZaKKBroGuh66DroRugG6HvQz+AfgjdBP0Iuhn6MfQT6BboVug26Hbop9Ad0J3QXdDd0D3Qz6CfQ7+Afgn9Cvo19Bvot9DvoN9D90J/gP4I/Qn6M/QX6K/Q36C/Q/+A/gn9C/o39B/ov9B9MDEw+3+PH8bAVIGpClMNpjpMDZiaMIfAHApzGEwtmNowdWDqwhwOUw+mPswRMA1gjoRpCHMUzNEwx8AcC3McTCOYxjDHwzSBOQHmRJiTYE6GaQpzCkwzmOYwLWBawrSCaQ3TBqYtTDuY9jAdYDp6Z/be+bp3Fu6dW3tnzN55sHd2652zemei3vmld9bonQt6Z3jeeZt3NuadY3lnTt75kHeW4527eGck3nmGd/bgnRN4e/re/ru3V+7ta3t70N5+sbe36+3Denum3v6mtxfp7Rt6e3zefpy3d+btc3l7Ut7+kbfX4+3LeHso3n6Htzfh7SN4a35vfe6tpb11r7dG9daT3trPW6d5aypv/eOtVbx1hbcG8Obr3tzamwd7c1ZvfunNBb15mzfH8uY6cwb4MjIDKV0TMhK2xHSMETVVqlarXqPmIYceVqt2nbqH16t/RIMjGx519DHHHteo8fFNTjjxpJObntKseYuWrVq3aduufYfs7MnBrOmdE/2Bk4Jr11X/+ufVK0dkZx/8qGnxj9oU/yguuLbm78uGTvimdkb+R92Ca1fFVP8k48q4+fkfXRZcO+/QDV2WTakxNP+jK4p/dHVxfGLYRw8HNzdPODBpjE9MHZWWkOEfluyLTw0kJHr/G+0LpPtTU+KvDySkpfkCW2LqZs2ITU1Jz8jNmtnVH/AlZmjWrJ4pGb4RvsC0wad2LHsuWfT7EtX3x8cV/X5MdPnjsqbHJiQn5xxawJk9wJfsXfRoX5RXElOcYKIlPLu/LkleP4tNTRtTcElx4XUKg+fVvHaFax5XCTWfPjAjNS0nGKGmRe5R7Ixufl9y2XtmjYt+savjF2Nm5g3ZrLndUgM+/4iU/S31oNevx2b4EuNH+dMT4/O6eGxBD+93oIMPyevf+wfGvLzlS+ekpIAvPb2g6hE+7xrMmjnQPyot2ZdXxcJ/Olid4GJ/enxKZnKyf7jfF4hP86Uk+VNG/PeDqFsFB1G34h2oSnQELU6oWjmDJza8TmHwaX1SRxfqrgXxRX5iCm7xwQFX62BESaOzogMprsItKcWHogmHFRoRS/MGRFpgdLw/vW9+x+yf1y9zinb1ECUnv3sX1G3q4A7BiPEa8Sem1GFT/CaFqpA/pOYn+fa/plLTffEj/SkZW2Ia/O8NJlPeKyhvJ3IYTIU6VeTBVOKQ6RoeGmkwmQpfRdcKP1S0+GAq9BDxrq5IBUt4B08f3KFjp2Kh4e13sLfP6+JPSQiMOfCHfmmTwgKmDcwcVsarNfTT/Hdk/Q4xm47ffvqYVkeekdpv9O3bB827+YhpLT6vc9R3meeO/mNLauR8Vaf1yUyOcFWRh6Qp/uQMEfOH6+zkjPyB2vD/33r//9Y78B//rRe5q8+Muy4zITk9Qo+e2StzVFrP4WHYqnWzpu//MKd+afNu73XoUOcibV5onOUlaVDKQ2F2b+9VOmhkQkqk5cFBgsNLdHPTlNQM//Ax8YkBX0KGLylsknpw4ZcWSL1hzBP/8YjtWsER2/V/8NVa8YVrxVulrOVf4VVYk9CkM6/XxeZ1uoL5Z3Z25Kmn5pS8slqYnDoiv68WbE5c/B/317QK9te0Cr8f2hQnVKv0/lo1HH5wnlMQVVAIPRo7FQnqGipEDooLFSIHdQsVIgd1DxUiB/UIFSIH9QwVIgf1ChUiB10UKkQO6h0qRA7qEypEDuobKkQO6hcqRA7qHypEDro4VIgcNCBUiBw0MFSIHDQoVIgcNDhUiBw0JFSIHHRJqBA56NJQIXLQZaFC5KDLQ4XIQVeECpGDrgwVIgddFSpEDhoaKkQOig8VIgddHSqEB0V+C1b03dW1wk/IRkVrVzX0uijGrh4du3HW3Lz5n/elfmkPFoCneS/G/YBQprAM83p6+zcHWqdiLw8pkjyUoiB98WsusqA3xdeHB39SJbzKhX5S9H3izXI6l7a2rPCcLKHCfaAOsQ/U/R/qA1Uqsw8U3YrxYnpXeDacxp8Nl3Q3qxe9mybUEoUapkYooNDnNUNtmrfw65k1vXdqQlJBQLUQYYZXv4Cv+FerlVy3GkXrViN0o0v8Qs2iX6hZxhcOKVjLlpimemgdnv+FuPwTnorOkOtE6uDVindwE+kyShsVVcK+FL4Omh92GOUtXrKzJ5Wyf/5MD19CWudAIGFMWK+q1ijiN6qW/I3qdSaVsHPfKWtGXmBJ2/qdGhX78MD1Ff1K3nKsTv56bEHe08fLGe9P8U6NMyYXXQs1qOBa7IjKWcfEhOpTAC66anQ9dSy2WZM/VPM3mYrm1GId29QotuZ0zC6RssdM6+ofHXpJFNQh/ylVcNn5DfF/pbbesu5/AQA=",
       "custom_attributes": [
         "abi_private"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": false,
       "name": "publish_for_public_execution",
-      "verification_key": "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"
+      "verification_key": "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"
     },
     {
       "abi": {
@@ -5028,11 +5040,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "JwACBAEoAAABBIBJJwAABEklAAAARicCAwQBJwIEBAAfCgADAAQASBwASEgFLQhIAiUAAACCJwICBEknAgMEADsOAAMAAigAAEMFAlgsAABEADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAJwBFAQEnAEYEAScARwABJh4CAAQBCiIERAUWCgUGHAoGBwAEKgcEBicCBAEACioFBAckAgAHAAAAtScCCAQAPAYIAR4CAAUAKQIABwADbVJ/KwIACAAAAAAAAAAAAwAAAAAAAAAALQgBCScCCgQFAAgBCgEnAwkEAQAiCQIKLQoKCy0OBwsAIgsCCy0OBQsAIgsCCy0OBgsAIgsCCy0OCAstCAEFJwIHBAUACAEHAScDBQQBACIJAgcAIgUCCj8PAAcACgAiBUYHLQsHBzMKAAcABSQCAAUAAAFSJQAABgAMIgJDBQoqBQQHJAIABwAAAWklAAAGEikCAAUA71JTTS0IAQcnAgkEBQAIAQkBJwMHBAEAIgcCCS0KCQotDgUKACIKAgotDEcKACIKAgotDgYKACIKAgotDggKLQgBBScCBgQFAAgBBgEnAwUEAQAiBwIGACIFAgk/DwAGAAkAIgVGBi0LBgYnAgUAAAoqBgUHCioHBAUkAgAFAAAB9SUAAAYkHgIABAAvKgAGAAQABRwKBQcEHAoHBAACKgUEBywCAAQALV4Ji4K6N7Q7maExYRj9INQvUWbJ6fE/teplqW0eCm0EKgcEBRwKBQkEHAoJBwACKgUHCQQqCQQFHAoFCgIcCgoJABwKCQoCHAoKCwEcCgsJAicCCgIACioJCgsWCgsJHAoJDAACKgUMDSwCAAUAMDPqJG5QbomOl/Vwyv/XBMsLtGAxP7cgsp4TnlwQAAEEKg0FDBwKDA4EHAoODQACKgwNDgQqDgQMHAoMDgIcCg4EABwKBA4CHAoODwEcCg8EAgoqBAoOFgoOBBwKBAoAAioMCg8EKg8FChwKCgwEHAoMBQAcCgUKBRwKDgUFHAoEDAUEKgwKBBwKDQoFHAoLDAUcCgkLBQQqCwoJHAoHCgUeAgAHBgwqBwoLKQIACgUAAVGAJAIACwAAA0YjAAADVQQqBQoJACoECQMjAAADZAQqDAoEACoJBAMjAAADZAwqAwIFJAIABQAAA3YjAAADhCcCBQUALQoFBCMAAAOgAioDAgQOKgIDBSQCAAUAAAObJQAABjYjAAADoAAqBwQFDioHBQkkAgAJAAADtyUAAAZIHgIABAAvKgAGAAQABwAiBkcEHgIACQAvKgAEAAkACicCCQACACoGCQseAgAMAC8qAAsADAANHAoHDgQcCg4MABwKDAcAKQIADgD/////DioHDg8kAgAPAAAEFyUAAAZaHAoFBwAcCgcFACkCAA4A/////w4qBQ4PJAIADwAABDwlAAAGWhwKAgUAHAoFAgApAgAOAP////8OKgIODyQCAA8AAARhJQAABlocCgMCABwKAgMAKQIADgD/////DioDDg8kAgAPAAAEhiUAAAZaJwIDACAnAg8EEC0IABAtCgkSLQoDEwAIAA8AJQAABmwtAgAALQoSDgQqBw4DACoMAwcnAgMAQCcCDgQPLQgADy0KCREtCgMSAAgADgAlAAAGbC0CAAAtChEMACoHDAMnAgcASCcCDgQPLQgADy0KCREtCgcSAAgADgAlAAAGbC0CAAAtChEMBCoFDAcAKgMHBScCAwBoJwIMBA4tCAAOLQoJEC0KAxEACAAMACUAAAZsLQIAAC0KEAcAKgUHAycCBQBwJwIMBA4tCAAOLQoJEC0KBREACAAMACUAAAZsLQIAAC0KEAcEKgIHBQAqAwUCLQgBAycCBQQFAAgBBQEnAwMEAQAiAwIFLQoFBy0OAgcAIgcCBy0OCgcAIgcCBy0ODQcAIgcCBy0OCActCAEFJwIHBAUACAEHAScDBQQBACIDAgcAIgUCCD8PAAcACAAiBUYDLQsDAzAKAAIABjAKAAoABDAKAA0ACycCAgADACoGAgQwCgADAAQmKgEAAQXVEn0pwtLo7TwEAgEmKgEAAQVebT8u3M2HCTwEAgEmKgEAAQW6uyHXgjMYZDwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQXQB+v0y8ZnkDwEAgEmKgEAAQWtC9JCvZ8IXjwEAgEmJwIHBAInAggBAS0IAQYnAgkEIQAIAQkBJwMGBAEAIgYCCScCCgQgQwOqAAMABwAKAAgACS0CCQMtAgoEJQAAB0MnAgMEIScCBwQgLQhGBC0IRwUjAAAGxAwqBAMIJAIACAAABtYjAAAHPgQqBQUIAioHBAkOKgQHCiQCAAoAAAbyJQAABjYMKgkHCiQCAAoAAAcEJQAAB34AIgYCCwAqCwkKLQsKChwKCgkABCoIAgoEKgkKCwIoRwkKBCoKCAkAKgsJBQAiBEYILQoIBCMAAAbELQoFAiYtAAMHAAADBAgCAAgCCCMAAAdwLQEHBS0BCAYtBAYHLQQFCAAABwIHAgAIAggMAAcICSQAAAkAAAdWJioBAAEF5AhQRQK1jB88BAIBJg==",
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "set_update_delay"
     },
@@ -5088,17 +5100,17 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "JwACBAEoAAABBIBJJwAABEklAAAAQScCAwQBJwIEBAAfCgADAAQASC0ISAIlAAAAmycCAgRJJwIDBAA7DgADAAInAEMAASwAAEQALc/6U80Ocdp7SiJnezNCv8O5BD9Qgb6lg2itAI6qbzcsAABFADBkTnLhMaApuFBFtoGBWF0oM+hIeblwkUPh9ZPwAAAAJwBGAQEnAEcEASYeAgAEAQoiBEUFFgoFBhwKBgcABCoHBAYnAgQBAAoqBQQHJAIABwAAAM4nAggEADwGCAEeAgAFACkCAAcAA21SfysCAAgAAAAAAAAAAAMAAAAAAAAAAC0IAQknAgoEBQAIAQoBJwMJBAEAIgkCCi0KCgstDgcLACILAgstDgULACILAgstDgYLACILAgstDggLLQgBBScCCgQFAAgBCgEnAwUEAQAiCQIKACIFAgs/DwAKAAsAIgVHCS0LCQkzCgAJAAUkAgAFAAABayUAAAb0LQgBBScCCQQFAAgBCQEnAwUEAQAiBQIJLQoJCi0OBwoAIgoCCi0MQwoAIgoCCi0OAgoAIgoCCi0OCAotCAEHJwIJBAUACAEJAScDBwQBACIFAgkAIgcCCj8PAAkACgAiB0cFLQsFBTMKAAUAByQCAAcAAAHlJQAABwYpAgAFAO9SU00tCAEHJwIJBAUACAEJAScDBwQBACIHAgktCgkKLQ4FCgAiCgIKLQxDCgAiCgIKLQ4GCgAiCgIKLQ4ICi0IAQUnAgkEBQAIAQkBJwMFBAEAIgcCCQAiBQIKPw8ACQAKACIFRwctCwcHJwIFAAAKKgcFCQoqCQQFJAIABQAAAnElAAAHGB4CAAQALyoABwAEAAUAIgdDBB4CAAkALyoABAAJAAonAgkAAgAqBwkLHgIADAAvKgALAAwADRwKBQ4EHAoODAAcCgwFBR4CAAwALyoABwAMAA4cCg4PBBwKDwwAAioODA8sAgAMAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoPDA4cCg4QBBwKEA8AAioODxAEKhAMDhwKDhECHAoREAAcChARAhwKERIBHAoSEAInAhECAAoqEBESFgoSEBwKEBMAAioOExQsAgAOADAz6iRuUG6Jjpf1cMr/1wTLC7RgMT+3ILKeE55cEAABBCoUDhUcChUWBBwKFhQAAioVFBYEKhYMFRwKFRYCHAoWDAAcCgwWAhwKFhcBHAoXDAIKKgwRFhYKFgwcCgwRAAIqFREXBCoXDhUcChUXBBwKFw4AHAoOFQUcChYOBRwKDBYFBCoWFQwcChQVBRwKEhQFHAoQEgUEKhIVEBwKDxIFHgIAFQYMKhUSFikCABIFAAFRgCQCABYAAAQHIwAABBYEKg4SFAAqDBQDIwAABCUEKhQSDgAqEA4DIwAABCUAKhUDDg4qFQ4SJAIAEgAABDwlAAAHKgwqFQUDFgoDBRwKAxIAHAoFAwAEKhIKBQQqAw0KACoFCgMcCg4FABwKBQoAKQIADQD/////DioKDQ4kAgAOAAAEgyUAAAc8HAoPCgApAgANAP////8OKgoNDiQCAA4AAASjJQAABzwcChAKABwKCg0AKQIADgD/////DioNDhAkAgAQAAAEyCUAAAc8HAoMDQAcCg0MACkCAA4A/////w4qDA4QJAIAEAAABO0lAAAHPCcCDAAgJwIQBBQtCAAULQoJFi0KDBcACAAQACUAAAdOLQIAAC0KFg4EKg8ODAAqBQwOJwIMAEAnAhAEFC0IABQtCgkWLQoMFwAIABAAJQAAB04tAgAALQoWDwQqEw8MACoODA8nAgwASCcCEAQSLQgAEi0KCRQtCgwVAAgAEAAlAAAHTi0CAAAtChQOBCoKDgwAKg8MCicCDABoJwIPBBItCAASLQoJFC0KDBUACAAPACUAAAdOLQIAAC0KFA4EKhEODAAqCgwOJwIKAHAnAg8EEC0IABAtCgkSLQoKEwAIAA8AJQAAB04tAgAALQoSDAQqDQwJACoOCQotCAEJJwIMBAUACAEMAScDCQQBACIJAgwtCgwNLQ4KDQAiDQINLQ4DDQAiDQINLQ4CDQAiDQINLQ4IDS0IAQgnAgwEBQAIAQwBJwMIBAEAIgkCDAAiCAINPw8ADAANACIIRwktCwkJMAoACgAHMAoAAwAEMAoAAgALJwIEAAMAKgcECDAKAAkACCcCBwQFJwIJBAMAKgcJCC0IAQQACAEIAScDBAQBACIEAggtDgcIACIIAggtDgcIJwIIBAMAKgQIBy0KBwgtDEQIACIIAggtDgYIACIIAggtDgMIACIIAggtDgIIACIIAggtDgUIJwICBAUAIgQCBS0LBQUnAgYEAwAqBAYDNw4ABQADJioBAAEF1RJ9KcLS6O08BAIBJioBAAEFrpKPa6mOkow8BAIBJioBAAEFursh14IzGGQ8BAIBJioBAAEF0Afr9MvGZ5A8BAIBJioBAAEFrQvSQr2fCF48BAIBJicCBwQCJwIIAQEtCAEGJwIJBCEACAEJAScDBgQBACIGAgknAgoEIEMDqgADAAcACgAIAAktAgkDLQIKBCUAAAglJwIDBCEnAgcEIC0IRwQtCEMFIwAAB6YMKgQDCCQCAAgAAAe4IwAACCAEKgUFCAIqBwQJDioEBwokAgAKAAAH1CUAAAhgDCoJBwokAgAKAAAH5iUAAAhyACIGAgsAKgsJCi0LCgocCgoJAAQqCAIKBCoJCgsCKEMJCgQqCggJACoLCQUAIgRHCC0KCAQjAAAHpi0KBQImLQADBwAAAwQIAgAIAggjAAAIUi0BBwUtAQgGLQQGBy0EBQgAAAcCBwIACAIIDAAHCAkkAAAJAAAIOCYqAQABBRu8ZdA/3OrcPAQCASYqAQABBeQIUEUCtYwfPAQCASY=",
       "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.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
+  "noir_version": "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905",
   "outputs": {
     "globals": {},
     "structs": {
@@ -5524,5 +5536,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "0.0.1-commit.3100065"
+  "aztec_version": "0.0.1-commit.330febf"
 }