@aztec/protocol-contracts 6.0.0-nightly.20260604 → 6.0.0-nightly.20260721

package/artifacts/ContractInstanceRegistry.json

@@ -9,10 +9,14 @@
         {
           "name": "aes128_encrypt_padded_input",
           "start": 824
+        },
+        {
+          "name": "tests::encrypt",
+          "start": 921
         }
       ],
       "path": "std/aes128.nr",
-      "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n"
+      "source": "// docs:start:aes128\n/// Given a plaintext as an array of bytes, returns the corresponding aes128 ciphertext (CBC mode). Input padding is performed using PKCS#7, so that the output length is `input.len() + (16 - input.len() % 16)`.\npub fn aes128_encrypt<let N: u32>(\n    input: [u8; N],\n    iv: [u8; 16],\n    key: [u8; 16],\n) -> [u8; N + 16 - N % 16] {\n    let padding_length = (16 - N % 16) as u8;\n    let mut padded_input: [u8; N + 16 - N % 16] = [0; N + 16 - N % 16];\n    for i in 0..N {\n        padded_input[i] = input[i];\n    }\n    for i in N..N + 16 - N % 16 {\n        padded_input[i] = padding_length;\n    }\n    let output = aes128_encrypt_padded_input(padded_input, iv, key);\n    output\n}\n\n#[foreign(aes128_encrypt)]\nfn aes128_encrypt_padded_input<let N: u32>(input: [u8; N], iv: [u8; 16], key: [u8; 16]) -> [u8; N] {}\n\n// docs:end:aes128\n\nmod tests {\n    use super::aes128_encrypt;\n\n    #[test]\n    fn encrypt() {\n        let input = \"kevlovesrust\".as_bytes();\n        let iv = \"0000000000000000\".as_bytes();\n        let key = \"0000000000000000\".as_bytes();\n        let output = [244, 14, 126, 172, 171, 40, 208, 186, 173, 184, 226, 105, 238, 122, 205, 191];\n        assert_eq(aes128_encrypt(input, iv, key), output);\n    }\n}\n"
     },
     "14": {
       "function_locations": [
@@ -91,12 +95,176 @@
         {
           "name": "embedded_curve_add_array_return",
           "start": 5439
+        },
+        {
+          "name": "tests::hash_point",
+          "start": 5888
+        },
+        {
+          "name": "tests::hash_scalar",
+          "start": 6064
+        },
+        {
+          "name": "tests::point_new_sets_coordinates",
+          "start": 6236
+        },
+        {
+          "name": "tests::point_at_infinity_is_origin",
+          "start": 6395
+        },
+        {
+          "name": "tests::generator_has_documented_coordinates",
+          "start": 6579
+        },
+        {
+          "name": "tests::is_infinite_only_true_for_origin",
+          "start": 6803
+        },
+        {
+          "name": "tests::points_with_same_coords_are_equal",
+          "start": 7126
+        },
+        {
+          "name": "tests::points_with_different_coords_are_unequal",
+          "start": 7318
+        },
+        {
+          "name": "tests::neg_negates_y_coordinate",
+          "start": 7580
+        },
+        {
+          "name": "tests::neg_is_involution",
+          "start": 7768
+        },
+        {
+          "name": "tests::add_with_point_at_infinity_is_identity",
+          "start": 7913
+        },
+        {
+          "name": "tests::add_of_two_infinities_is_infinity",
+          "start": 8147
+        },
+        {
+          "name": "tests::add_with_negation_is_point_at_infinity",
+          "start": 8318
+        },
+        {
+          "name": "tests::add_is_commutative",
+          "start": 8458
+        },
+        {
+          "name": "tests::add_is_associative",
+          "start": 8620
+        },
+        {
+          "name": "tests::sub_of_a_point_with_itself_is_infinity",
+          "start": 8841
+        },
+        {
+          "name": "tests::sub_with_point_at_infinity_is_identity",
+          "start": 8998
+        },
+        {
+          "name": "tests::sub_inverts_add",
+          "start": 9183
+        },
+        {
+          "name": "tests::double_equals_self_plus_self",
+          "start": 9394
+        },
+        {
+          "name": "tests::double_of_point_at_infinity_is_infinity",
+          "start": 9551
+        },
+        {
+          "name": "tests::embedded_curve_add_matches_add_operator",
+          "start": 9701
+        },
+        {
+          "name": "tests::point_hash_is_consistent_for_equal_points",
+          "start": 9905
+        },
+        {
+          "name": "tests::point_hash_differs_for_distinct_points",
+          "start": 10117
+        },
+        {
+          "name": "tests::scalar_new_sets_limbs",
+          "start": 10515
+        },
+        {
+          "name": "tests::scalars_with_same_limbs_are_equal",
+          "start": 10683
+        },
+        {
+          "name": "tests::scalars_with_different_limbs_are_unequal",
+          "start": 10877
+        },
+        {
+          "name": "tests::scalar_from_field_decomposes_zero",
+          "start": 11098
+        },
+        {
+          "name": "tests::scalar_from_field_decomposes_small_value",
+          "start": 11256
+        },
+        {
+          "name": "tests::scalar_from_field_decomposes_two_pow_128",
+          "start": 11455
+        },
+        {
+          "name": "tests::scalar_hash_is_consistent_for_equal_scalars",
+          "start": 11645
+        },
+        {
+          "name": "tests::scalar_hash_differs_for_distinct_scalars",
+          "start": 11865
+        },
+        {
+          "name": "tests::msm_with_scalar_one_returns_point",
+          "start": 12288
+        },
+        {
+          "name": "tests::msm_with_scalar_zero_returns_infinity",
+          "start": 12507
+        },
+        {
+          "name": "tests::msm_with_scalar_two_doubles_point",
+          "start": 12732
+        },
+        {
+          "name": "tests::msm_sums_terms",
+          "start": 12937
+        },
+        {
+          "name": "tests::msm_with_opposite_terms_cancels",
+          "start": 13167
+        },
+        {
+          "name": "tests::msm_skips_point_at_infinity",
+          "start": 13393
+        },
+        {
+          "name": "tests::msm_skips_zero_scalar",
+          "start": 13665
+        },
+        {
+          "name": "tests::fixed_base_scalar_mul_with_one_returns_generator",
+          "start": 13955
+        },
+        {
+          "name": "tests::fixed_base_scalar_mul_with_zero_returns_infinity",
+          "start": 14164
+        },
+        {
+          "name": "tests::fixed_base_scalar_mul_matches_msm_on_generator",
+          "start": 14351
         }
       ],
       "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"
+      "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"
     },
-    "148": {
+    "147": {
       "function_locations": [
         {
           "name": "<impl Empty for AztecAddress>::empty",
@@ -180,11 +348,11 @@
         },
         {
           "name": "to_address_point_invalid",
-          "start": 12922
+          "start": 12908
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/aztec_address.nr",
-      "source": "use crate::{\n    address::{\n        partial_address::PartialAddress, salted_initialization_hash::SaltedInitializationHash,\n    },\n    constants::{AZTEC_ADDRESS_LENGTH, DOM_SEP__CONTRACT_ADDRESS_V2, MAX_FIELD_VALUE},\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    public_keys::{hash_public_key, IvpkM, PublicKeys, ToPoint},\n    traits::{Deserialize, Empty, FromField, Packable, Serialize, ToField},\n    utils::field::sqrt,\n};\n\nuse crate::point::EmbeddedCurvePoint;\n\nuse crate::public_keys::AddressPoint;\nuse std::{\n    embedded_curve_ops::{EmbeddedCurveScalar, fixed_base_scalar_mul as derive_public_key},\n    ops::Add,\n};\nuse std::meta::derive;\n\n// Aztec address\n#[derive(Deserialize, Eq, Packable, Serialize)]\npub struct AztecAddress {\n    pub inner: Field,\n}\n\nimpl Empty for AztecAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl ToField for AztecAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl FromField for AztecAddress {\n    fn from_field(value: Field) -> AztecAddress {\n        AztecAddress { inner: value }\n    }\n}\n\nimpl AztecAddress {\n    pub fn zero() -> Self {\n        Self { inner: 0 }\n    }\n\n    /// Returns `true` if the address is valid.\n    ///\n    /// An invalid address is one that can be proven to not be correctly derived, meaning it contains no contract code,\n    /// public keys, etc., and can therefore not receive messages nor execute calls.\n    pub fn is_valid(self) -> bool {\n        self.get_y().is_some()\n    }\n\n    /// Returns an address's [`AddressPoint`].\n    ///\n    /// This can be used to create shared secrets with the owner of the address. If the address is invalid (see\n    /// [`AztecAddress::is_valid`]) then this returns `Option::none()`, and no shared secrets can be created.\n    pub fn to_address_point(self) -> Option<AddressPoint> {\n        self.get_y().map(|y| {\n            // If we get a negative y coordinate (y > (r - 1) / 2), we swap it to the\n            // positive one (where y <= (r - 1) / 2) by negating it.\n            let final_y = if Self::is_positive(y) { y } else { -y };\n\n            AddressPoint { inner: EmbeddedCurvePoint { x: self.inner, y: final_y } }\n        })\n    }\n\n    /// Determines whether a y-coordinate is in the lower (positive) or upper (negative) \"half\" of the field.\n    /// I.e.\n    /// y <= (r - 1)/2 => positive.\n    /// y > (r - 1)/2 => negative.\n    /// An AddressPoint always uses the \"positive\" y.\n    fn is_positive(y: Field) -> bool {\n        // Note: The field modulus r is MAX_FIELD_VALUE + 1.\n        let MID = MAX_FIELD_VALUE / 2; // (r - 1) / 2\n        let MID_PLUS_1 = MID + 1; // (r - 1)/2 + 1\n        // Note: y <= m implies y < m + 1.\n        y.lt(MID_PLUS_1)\n    }\n\n    /// Returns one of the two possible y-coordinates.\n    ///\n    /// Not all `AztecAddresses` are valid, in which case there is no corresponding y-coordinate. This returns\n    /// `Option::none()` for invalid addresses.\n    ///\n    /// An `AztecAddress` is defined by an x-coordinate, for which two y-coordinates exist as solutions to the curve\n    /// equation. This function returns either of them. Note that an [`AddressPoint`] must **always** have a positive\n    /// y-coordinate - if trying to obtain the underlying point use [`AztecAddress::to_address_point`] instead.\n    fn get_y(self) -> Option<Field> {\n        // We compute the address point by taking our address as x, and then solving for y in the\n        // equation which defines the grumpkin curve:\n        // y^2 = x^3 - 17; x = address\n        let x = self.inner;\n        let y_squared = x * x * x - 17;\n\n        sqrt(y_squared)\n    }\n\n    pub fn compute(public_keys: PublicKeys, partial_address: PartialAddress) -> AztecAddress {\n        //\n        //                          address = address_point.x\n        //                                          |\n        //                                    address_point = pre_address * G + Ivpk_m (always choose \"positive\" y-coord)\n        //                                                        |               ^\n        //                                                        |               |.....................\n        //                                                    pre_address                              .\n        //                                               /                   \\                         .\n        //                                             /                       \\                       .\n        //                               partial_address                        public_keys_hash       .\n        //                           /                    \\                  /  /  |  |  |   \\         .\n        //                         /                        \\                /  /   |  |  |    \\       .\n        //                                                              npk_m_hash Ivpk_m  ovpk_m_hash  tpk_m_hash  mspk_m_hash  fbpk_m_hash\n        //          contract_class_id                         \\                     |.........................\n        //             /   |    \\                               \\\n        // artifact_hash   |    public_bytecode_commitment        salted_initialization_hash\n        //                 |                                      /        /                  \\                  \\\n        //     private_function_tree_root           salt   initialization_hash         deployer_address     immutables_hash\n        //             /       \\                              /             \\\n        //          ...          ...                 constructor_fn_selector   constructor_args_hash\n        //         /                \\\n        //     /     \\            /      \\\n        //   leaf   leaf        leaf    leaf\n        //           ^\n        //           |\n        //           |---h(function_selector, vk_hash)\n        //               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n        //               Each of these represents a private function of the contract.\n\n        let public_keys_hash = public_keys.hash();\n\n        let pre_address = poseidon2_hash_with_separator(\n            [public_keys_hash.to_field(), partial_address.to_field()],\n            DOM_SEP__CONTRACT_ADDRESS_V2,\n        );\n\n        // Note: `.add()` will fail within the blackbox fn if either of the points are not on the curve. (See tests below).\n        let address_point = derive_public_key(EmbeddedCurveScalar::from_field(pre_address)).add(\n            public_keys.ivpk_m.to_point(),\n        );\n\n        // Note that our address is only the x-coordinate of the full address_point. This is okay because when people want to encrypt something and send it to us\n        // they can recover our full point using the x-coordinate (our address itself). To do this, they recompute the y-coordinate according to the equation y^2 = x^3 - 17.\n        // When they do this, they may get a positive y-coordinate (a value that is less than or equal to MAX_FIELD_VALUE / 2) or\n        // a negative y-coordinate (a value that is more than MAX_FIELD_VALUE), and we cannot dictate which one they get and hence the recovered point may sometimes be different than the one\n        // our secret can decrypt. Regardless though, they should and will always encrypt using point with the positive y-coordinate by convention.\n        // This ensures that everyone encrypts to the same point given an arbitrary x-coordinate (address). This is allowed because even though our original point may not have a positive y-coordinate,\n        // with our original secret, we will be able to derive the secret to the point with the flipped (and now positive) y-coordinate that everyone encrypts to.\n        AztecAddress::from_field(address_point.x)\n    }\n\n    pub fn compute_from_class_id(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n        public_keys: PublicKeys,\n    ) -> Self {\n        let partial_address = PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            salted_initialization_hash,\n        );\n\n        AztecAddress::compute(public_keys, partial_address)\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.inner == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\n#[test]\nfn check_max_field_value() {\n    // Check that it is indeed r-1.\n    assert_eq(MAX_FIELD_VALUE + 1, 0);\n}\n\n#[test]\nfn check_is_positive() {\n    assert(AztecAddress::is_positive(0));\n    assert(AztecAddress::is_positive(1));\n    assert(!AztecAddress::is_positive(-1));\n    assert(AztecAddress::is_positive(MAX_FIELD_VALUE / 2));\n    assert(!AztecAddress::is_positive((MAX_FIELD_VALUE / 2) + 1));\n}\n\n// Gives us confidence that we don't need to manually check that the input public keys need to be on the curve for `add`,\n// because the blackbox function does this check for us.\n#[test(should_fail_with = \"is not on curve\")]\nfn check_embedded_curve_point_add() {\n    // Choose a point not on the curve in the 2nd position.\n    let p1 = EmbeddedCurvePoint::generator();\n    let key = IvpkM { inner: EmbeddedCurvePoint { x: 1, y: 1 } };\n    let _ = p1 + key.to_point();\n}\n\n#[test]\nfn compute_address_from_partial_and_pub_keys() {\n    let npk_m_point = EmbeddedCurvePoint {\n        x: 0x22f7fcddfa3ce3e8f0cc8e82d7b94cdd740afa3e77f8e4a63ea78a239432dcab,\n        y: 0x0471657de2b6216ade6c506d28fbc22ba8b8ed95c871ad9f3e3984e90d9723a7,\n    };\n    let ovpk_m_point = EmbeddedCurvePoint {\n        x: 0x09115c96e962322ffed6522f57194627136b8d03ac7469109707f5e44190c484,\n        y: 0x0c49773308a13d740a7f0d4f0e6163b02c5a408b6f965856b6a491002d073d5b,\n    };\n    let tpk_m_point = EmbeddedCurvePoint {\n        x: 0x00d3d81beb009873eb7116327cf47c612d5758ef083d4fda78e9b63980b2a762,\n        y: 0x2f567d22d2b02fe1f4ad42db9d58a36afd1983e7e2909d1cab61cafedad6193a,\n    };\n    let mspk_m_point = EmbeddedCurvePoint {\n        x: 0x1bd6cb13e0bc8c6e0c1a8b2c5d7f9e0a4b6c8d0e2f4a6c8e0a2c4e6f8a0b2c4d,\n        y: 0x0a032ec7b21c2bdb35f8a13e594764e39ee786c4b275eef3f0435bf6ab2b9822,\n    };\n    let fbpk_m_point = EmbeddedCurvePoint {\n        x: 0x2c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c8e0a2c4e6f8b0d2f4a6c90,\n        y: 0x2ef338da3a77e65f90b6d48ac686fc9ff3a95de0c39e0426fc443377425e6634,\n    };\n\n    let public_keys = PublicKeys {\n        npk_m_hash: hash_public_key(npk_m_point),\n        ivpk_m: IvpkM {\n            inner: EmbeddedCurvePoint {\n                x: 0x111223493147f6785514b1c195bb37a2589f22a6596d30bb2bb145fdc9ca8f1e,\n                y: 0x273bbffd678edce8fe30e0deafc4f66d58357c06fd4a820285294b9746c3be95,\n            },\n        },\n        ovpk_m_hash: hash_public_key(ovpk_m_point),\n        tpk_m_hash: hash_public_key(tpk_m_point),\n        mspk_m_hash: hash_public_key(mspk_m_point),\n        fbpk_m_hash: hash_public_key(fbpk_m_point),\n    };\n\n    let partial_address = PartialAddress::from_field(\n        0x0a7c585381b10f4666044266a02405bf6e01fa564c8517d4ad5823493abd31de,\n    );\n\n    let address = AztecAddress::compute(public_keys, partial_address).to_field();\n\n    let expected_computed_address_from_partial_and_pubkeys =\n        0x303ffc8bd456d132463b1fc3a633aeb718a7883c268f3956c05e6fe09b5a5424;\n    assert_eq(address, expected_computed_address_from_partial_and_pubkeys);\n}\n\n#[test]\nfn compute_preaddress_from_partial_and_pub_keys() {\n    let pre_address = poseidon2_hash_with_separator([1, 2], DOM_SEP__CONTRACT_ADDRESS_V2);\n    let expected_computed_preaddress_from_partial_and_pubkey =\n        0x0fa1c698858df1a99170cd39d5f4bfad6d0d60f1f8afa3dc92281ee60b36f3bb;\n    assert(pre_address == expected_computed_preaddress_from_partial_and_pubkey);\n}\n\n#[test]\nfn from_field_to_field() {\n    let address = AztecAddress { inner: 37 };\n    assert_eq(FromField::from_field(address.to_field()), address);\n}\n\n#[test]\nfn serde() {\n    let address = AztecAddress { inner: 37 };\n    // We use the AZTEC_ADDRESS_LENGTH constant to ensure that there is a match between the derived trait\n    // implementation and the constant.\n    let serialized: [Field; AZTEC_ADDRESS_LENGTH] = address.serialize();\n    let deserialized = AztecAddress::deserialize(serialized);\n    assert_eq(address, deserialized);\n}\n\n#[test]\nfn to_address_point_valid() {\n    // x = 8 where x^3 - 17 = 512 - 17 = 495, which is a residue in this field\n    let address = AztecAddress { inner: 8 };\n\n    assert(address.get_y().is_some()); // We don't bother checking the result of get_y as it is only used internally\n    assert(address.is_valid());\n\n    let maybe_point = address.to_address_point();\n    assert(maybe_point.is_some());\n\n    let point = maybe_point.unwrap().inner;\n    // check that x is preserved\n    assert_eq(point.x, Field::from(8));\n\n    // check that the curve equation holds: y^2 == x^3 - 17\n    assert_eq(point.y * point.y, point.x * point.x * point.x - 17);\n}\n\n#[test]\nunconstrained fn to_address_point_invalid() {\n    // x = 3 where x^3 - 17 = 27 - 17 = 10, which is a non-residue in this field\n    let address = AztecAddress { inner: 3 };\n\n    assert(address.get_y().is_none());\n    assert(!address.is_valid());\n\n    assert(address.to_address_point().is_none());\n}\n"
+      "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": {
       "function_locations": [
@@ -226,37 +394,37 @@
         },
         {
           "name": "tests::check_decompose",
-          "start": 3607
+          "start": 3678
         },
         {
           "name": "tests::check_lte_hint",
-          "start": 3857
+          "start": 3928
         },
         {
           "name": "tests::check_gt",
-          "start": 4164
+          "start": 4261
         },
         {
           "name": "tests::check_plo_phi",
-          "start": 4494
+          "start": 4591
         },
         {
           "name": "tests::check_decompose_edge_cases",
-          "start": 4989
+          "start": 5086
         },
         {
           "name": "tests::check_decompose_large_values",
-          "start": 5349
+          "start": 5446
         },
         {
           "name": "tests::check_lt_comprehensive",
-          "start": 5710
+          "start": 5807
         }
       ],
       "path": "std/field/bn254.nr",
-      "source": "use crate::field::field_less_than;\nuse crate::runtime::is_unconstrained;\n\n// The low and high decomposition of the field modulus\npub(crate) global PLO: Field = 53438638232309528389504892708671455233;\npub(crate) global PHI: Field = 64323764613183177041862057485226039389;\n\npub(crate) global TWO_POW_128: Field = 0x100000000000000000000000000000000;\n\n// Decomposes a single field into two 16 byte fields.\nfn compute_decomposition(x: Field) -> (Field, Field) {\n    // Here's we're taking advantage of truncating 128 bit limbs from the input field\n    // and then subtracting them from the input such the field division is equivalent to integer division.\n    let low = (x as u128) as Field;\n    let high = (x - low) / TWO_POW_128;\n\n    (low, high)\n}\n\npub(crate) unconstrained fn decompose_hint(x: Field) -> (Field, Field) {\n    compute_decomposition(x)\n}\n\nunconstrained fn lte_hint(x: Field, y: Field) -> bool {\n    if x == y {\n        true\n    } else {\n        field_less_than(x, y)\n    }\n}\n\n// Assert that (alo > blo && ahi >= bhi) || (alo <= blo && ahi > bhi)\nfn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {\n    let (alo, ahi) = a;\n    let (blo, bhi) = b;\n    // Safety: borrow is enforced to be boolean due to its type.\n    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)\n    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)\n    unsafe {\n        let borrow = lte_hint(alo, blo);\n\n        let rlo = alo - blo - 1 + (borrow as Field) * TWO_POW_128;\n        let rhi = ahi - bhi - (borrow as Field);\n\n        rlo.assert_max_bit_size::<128>();\n        rhi.assert_max_bit_size::<128>();\n    }\n}\n\n/// Decompose a single field into two 16 byte fields.\npub fn decompose(x: Field) -> (Field, Field) {\n    if is_unconstrained() {\n        compute_decomposition(x)\n    } else {\n        // Safety: decomposition is properly checked below\n        unsafe {\n            // Take hints of the decomposition\n            let (xlo, xhi) = decompose_hint(x);\n\n            // Range check the limbs\n            xlo.assert_max_bit_size::<128>();\n            xhi.assert_max_bit_size::<128>();\n\n            // Check that the decomposition is correct\n            assert_eq(x, xlo + TWO_POW_128 * xhi);\n\n            // Assert that the decomposition of P is greater than the decomposition of x\n            assert_gt_limbs((PLO, PHI), (xlo, xhi));\n            (xlo, xhi)\n        }\n    }\n}\n\npub fn assert_gt(a: Field, b: Field) {\n    if is_unconstrained() {\n        assert(\n            // Safety: already unconstrained\n            unsafe { field_less_than(b, a) },\n        );\n    } else {\n        // Decompose a and b\n        let a_limbs = decompose(a);\n        let b_limbs = decompose(b);\n\n        // Assert that a_limbs is greater than b_limbs\n        assert_gt_limbs(a_limbs, b_limbs)\n    }\n}\n\npub fn assert_lt(a: Field, b: Field) {\n    assert_gt(b, a);\n}\n\npub fn gt(a: Field, b: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unsafe in unconstrained\n        unsafe {\n            field_less_than(b, a)\n        }\n    } else if a == b {\n        false\n    } else {\n        // Safety: Take a hint of the comparison and verify it\n        unsafe {\n            if field_less_than(a, b) {\n                assert_gt(b, a);\n                false\n            } else {\n                assert_gt(a, b);\n                true\n            }\n        }\n    }\n}\n\npub fn lt(a: Field, b: Field) -> bool {\n    gt(b, a)\n}\n\nmod tests {\n    // TODO: Allow imports from \"super\"\n    use crate::field::bn254::{assert_gt, decompose, gt, lt, lte_hint, PHI, PLO, TWO_POW_128};\n\n    #[test]\n    fn check_decompose() {\n        assert_eq(decompose(TWO_POW_128), (0, 1));\n        assert_eq(decompose(TWO_POW_128 + 0x1234567890), (0x1234567890, 1));\n        assert_eq(decompose(0x1234567890), (0x1234567890, 0));\n    }\n\n    #[test]\n    unconstrained fn check_lte_hint() {\n        assert(lte_hint(0, 1));\n        assert(lte_hint(0, 0x100));\n        assert(lte_hint(0x100, TWO_POW_128 - 1));\n        assert(!lte_hint(0 - 1, 0));\n\n        assert(lte_hint(0, 0));\n        assert(lte_hint(0x100, 0x100));\n        assert(lte_hint(0 - 1, 0 - 1));\n    }\n\n    #[test]\n    fn check_gt() {\n        assert(gt(1, 0));\n        assert(gt(0x100, 0));\n        assert(gt((0 - 1), (0 - 2)));\n        assert(gt(TWO_POW_128, 0));\n        assert(!gt(0, 0));\n        assert(!gt(0, 0x100));\n        assert(gt(0 - 1, 0 - 2));\n        assert(!gt(0 - 2, 0 - 1));\n        assert_gt(0 - 1, 0);\n    }\n\n    #[test]\n    fn check_plo_phi() {\n        assert_eq(PLO + PHI * TWO_POW_128, 0);\n        let p_bytes = crate::field::modulus_le_bytes();\n        let mut p_low: Field = 0;\n        let mut p_high: Field = 0;\n\n        let mut offset = 1;\n        for i in 0..16 {\n            p_low += (p_bytes[i] as Field) * offset;\n            p_high += (p_bytes[i + 16] as Field) * offset;\n            offset *= 256;\n        }\n        assert_eq(p_low, PLO);\n        assert_eq(p_high, PHI);\n    }\n\n    #[test]\n    fn check_decompose_edge_cases() {\n        assert_eq(decompose(0), (0, 0));\n        assert_eq(decompose(TWO_POW_128 - 1), (TWO_POW_128 - 1, 0));\n        assert_eq(decompose(TWO_POW_128 + 1), (1, 1));\n        assert_eq(decompose(TWO_POW_128 * 2), (0, 2));\n        assert_eq(decompose(TWO_POW_128 * 2 + 0x1234567890), (0x1234567890, 2));\n    }\n\n    #[test]\n    fn check_decompose_large_values() {\n        let large_field = 0xffffffffffffffff;\n        let (lo, hi) = decompose(large_field);\n        assert_eq(large_field, lo + TWO_POW_128 * hi);\n\n        let large_value = large_field - TWO_POW_128;\n        let (lo2, hi2) = decompose(large_value);\n        assert_eq(large_value, lo2 + TWO_POW_128 * hi2);\n    }\n\n    #[test]\n    fn check_lt_comprehensive() {\n        assert(lt(0, 1));\n        assert(!lt(1, 0));\n        assert(!lt(0, 0));\n        assert(!lt(42, 42));\n\n        assert(lt(TWO_POW_128 - 1, TWO_POW_128));\n        assert(!lt(TWO_POW_128, TWO_POW_128 - 1));\n    }\n}\n"
+      "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"
     },
-    "151": {
+    "150": {
       "function_locations": [
         {
           "name": "<impl ToField for PartialAddress>::to_field",
@@ -298,7 +466,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/address/partial_address.nr",
       "source": "use crate::{\n    address::{aztec_address::AztecAddress, salted_initialization_hash::SaltedInitializationHash},\n    constants::DOM_SEP__PARTIAL_ADDRESS,\n    contract_class_id::ContractClassId,\n    hash::poseidon2_hash_with_separator,\n    traits::{Deserialize, Empty, Serialize, ToField},\n};\nuse std::meta::derive;\n\n// Partial address\n#[derive(Deserialize, Eq, Serialize)]\npub struct PartialAddress {\n    pub inner: Field,\n}\n\nimpl ToField for PartialAddress {\n    fn to_field(self) -> Field {\n        self.inner\n    }\n}\n\nimpl Empty for PartialAddress {\n    fn empty() -> Self {\n        Self { inner: 0 }\n    }\n}\n\nimpl PartialAddress {\n    pub fn from_field(field: Field) -> Self {\n        Self { inner: field }\n    }\n\n    pub fn compute(\n        contract_class_id: ContractClassId,\n        salt: Field,\n        initialization_hash: Field,\n        deployer: AztecAddress,\n        immutables_hash: Field,\n    ) -> Self {\n        PartialAddress::compute_from_salted_initialization_hash(\n            contract_class_id,\n            SaltedInitializationHash::compute(salt, initialization_hash, deployer, immutables_hash),\n        )\n    }\n\n    pub fn compute_from_salted_initialization_hash(\n        contract_class_id: ContractClassId,\n        salted_initialization_hash: SaltedInitializationHash,\n    ) -> Self {\n        PartialAddress::from_field(poseidon2_hash_with_separator(\n            [contract_class_id.to_field(), salted_initialization_hash.to_field()],\n            DOM_SEP__PARTIAL_ADDRESS,\n        ))\n    }\n\n    pub fn to_field(self) -> Field {\n        self.inner\n    }\n\n    pub fn is_zero(self) -> bool {\n        self.to_field() == 0\n    }\n\n    pub fn assert_is_zero(self) {\n        assert(self.to_field() == 0);\n    }\n}\n\nmod test {\n    use crate::{address::partial_address::PartialAddress, traits::{Deserialize, Serialize}};\n\n    #[test]\n    fn serialization_of_partial_address() {\n        let item = PartialAddress::from_field(1);\n        let serialized: [Field; 1] = item.serialize();\n        let deserialized = PartialAddress::deserialize(serialized);\n        assert_eq(item, deserialized);\n    }\n}\n"
     },
-    "153": {
+    "152": {
       "function_locations": [
         {
           "name": "<impl ToField for SaltedInitializationHash>::to_field",
@@ -364,183 +532,223 @@
         },
         {
           "name": "Field::from_le_bytes",
-          "start": 7918
+          "start": 8073
         },
         {
           "name": "Field::from_be_bytes",
-          "start": 8476
+          "start": 8820
+        },
+        {
+          "name": "Field::from_le_bytes_checked",
+          "start": 9611
+        },
+        {
+          "name": "Field::from_be_bytes_checked",
+          "start": 10620
         },
         {
           "name": "__assert_max_bit_size",
-          "start": 8757
+          "start": 11202
         },
         {
           "name": "__to_le_radix",
-          "start": 8885
+          "start": 11330
         },
         {
           "name": "__to_be_radix",
-          "start": 9013
+          "start": 11458
         },
         {
           "name": "__to_le_bits",
-          "start": 9734
+          "start": 12179
         },
         {
           "name": "__to_be_bits",
-          "start": 10452
+          "start": 12897
         },
         {
           "name": "modulus_num_bits",
-          "start": 10527
+          "start": 12972
         },
         {
           "name": "modulus_be_bits",
-          "start": 10603
+          "start": 13048
         },
         {
           "name": "modulus_le_bits",
-          "start": 10679
+          "start": 13124
         },
         {
           "name": "modulus_be_bytes",
-          "start": 10755
+          "start": 13200
         },
         {
           "name": "modulus_le_bytes",
-          "start": 10831
+          "start": 13276
         },
         {
           "name": "__field_less_than",
-          "start": 10992
+          "start": 13437
         },
         {
           "name": "field_less_than",
-          "start": 11068
-        },
-        {
-          "name": "bytes32_to_field",
-          "start": 11210
+          "start": 13513
         },
         {
           "name": "lt_fallback",
-          "start": 11617
+          "start": 13589
         },
         {
           "name": "tests::test_to_be_bits",
-          "start": 12579
+          "start": 14551
         },
         {
           "name": "tests::test_to_le_bits",
-          "start": 12852
+          "start": 14824
         },
         {
           "name": "tests::test_to_be_bytes",
-          "start": 13127
+          "start": 15099
         },
         {
           "name": "tests::test_to_le_bytes",
-          "start": 13433
+          "start": 15405
         },
         {
           "name": "tests::test_to_be_radix",
-          "start": 13739
+          "start": 15711
         },
         {
           "name": "tests::test_to_le_radix",
-          "start": 14321
+          "start": 16293
         },
         {
           "name": "tests::test_to_le_radix_1",
-          "start": 14921
+          "start": 16893
         },
         {
           "name": "tests::test_to_le_radix_brillig_1",
-          "start": 15374
+          "start": 17346
         },
         {
           "name": "tests::test_to_le_radix_3",
-          "start": 15728
+          "start": 17700
         },
         {
           "name": "tests::test_to_le_radix_brillig_3",
-          "start": 16039
+          "start": 18011
         },
         {
           "name": "tests::test_to_le_radix_512",
-          "start": 16467
+          "start": 18439
         },
         {
           "name": "tests::not_enough_limbs_brillig",
-          "start": 16876
+          "start": 18848
         },
         {
           "name": "tests::not_enough_limbs",
-          "start": 17072
+          "start": 19044
+        },
+        {
+          "name": "tests::non_zero_field_to_le_bytes_zero_limbs",
+          "start": 19274
+        },
+        {
+          "name": "tests::non_zero_field_to_be_bytes_zero_limbs",
+          "start": 19469
         },
         {
           "name": "tests::test_field_less_than",
-          "start": 17214
+          "start": 19576
         },
         {
           "name": "tests::test_large_field_values_unconstrained",
-          "start": 17469
+          "start": 19831
         },
         {
           "name": "tests::test_large_field_values",
-          "start": 17922
+          "start": 20284
         },
         {
           "name": "tests::test_decomposition_edge_cases",
-          "start": 18369
+          "start": 20731
         },
         {
           "name": "tests::test_pow_32",
-          "start": 18959
+          "start": 21321
         },
         {
           "name": "tests::test_sgn0",
-          "start": 19288
+          "start": 21650
         },
         {
           "name": "tests::test_bit_decomposition_overflow",
-          "start": 19710
+          "start": 22072
         },
         {
           "name": "tests::test_byte_decomposition_overflow",
-          "start": 19992
+          "start": 22354
         },
         {
           "name": "tests::test_to_from_be_bytes_bn254_edge_cases",
-          "start": 20209
+          "start": 22571
         },
         {
           "name": "tests::test_to_from_le_bytes_bn254_edge_cases",
-          "start": 22160
+          "start": 24522
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_accepts_modulus_minus_one",
+          "start": 26457
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_rejects_modulus",
+          "start": 26936
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_rejects_modulus_plus_one",
+          "start": 27321
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_accepts_modulus_minus_one",
+          "start": 27776
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_rejects_modulus",
+          "start": 28265
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_rejects_modulus_plus_one",
+          "start": 28650
+        },
+        {
+          "name": "tests::test_from_bytes_checked_small_n",
+          "start": 29094
         },
         {
           "name": "tests::from_le_bits",
-          "start": 24245
+          "start": 29739
         },
         {
           "name": "tests::from_be_bits",
-          "start": 24792
+          "start": 30286
         },
         {
           "name": "tests::test_to_from_be_bits_bn254_edge_cases",
-          "start": 25038
+          "start": 30532
         },
         {
           "name": "tests::test_to_from_le_bits_bn254_edge_cases",
-          "start": 26971
+          "start": 32465
         },
         {
           "name": "tests::max_bit_size_too_large",
-          "start": 28903
+          "start": 34397
         }
       ],
       "path": "std/field/mod.nr",
-      "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_le_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n\n    /// Convert a big endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    pub fn from_be_bytes<let N: u32>(bytes: [u8; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bytes[N - 1 - i] as Field) * v;\n            v = v * 256;\n        }\n        result\n    }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix<let N: u32>(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_le_bits)]\nfn __to_le_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n/// This array will be zero padded should not all bits be necessary to represent `self`.\n///\n/// # Failures\n/// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n/// be able to represent the original `Field`.\n///\n/// # Safety\n/// Values of `N` equal to or greater than the number of bits necessary to represent the `Field` modulus\n/// (e.g. 254 for the BN254 field) allow for multiple bit decompositions. This is due to how the `Field` will\n/// wrap around due to overflow when verifying the decomposition.\n#[builtin(to_be_bits)]\nfn __to_be_bits<let N: u32>(value: Field) -> [bool; N] {}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [bool] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [bool] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n    __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    if is_unconstrained() {\n        // Safety: unconstrained context\n        unsafe {\n            field_less_than(x, y)\n        }\n    } else {\n        let x_bytes: [u8; 32] = x.to_le_bytes();\n        let y_bytes: [u8; 32] = y.to_le_bytes();\n        let mut x_is_lt = false;\n        let mut done = false;\n        for i in 0..32 {\n            if (!done) {\n                let x_byte = x_bytes[32 - 1 - i] as u8;\n                let y_byte = y_bytes[32 - 1 - i] as u8;\n                let bytes_match = x_byte == y_byte;\n                if !bytes_match {\n                    x_is_lt = x_byte < y_byte;\n                    done = true;\n                }\n            }\n        }\n        x_is_lt\n    }\n}\n\nmod tests {\n    use crate::{panic::panic, runtime, static_assert};\n    use super::{\n        field_less_than, modulus_be_bits, modulus_be_bytes, modulus_le_bits, modulus_le_bytes,\n    };\n\n    #[test]\n    // docs:start:to_be_bits_example\n    fn test_to_be_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_be_bits();\n        assert_eq(bits, [false, false, false, false, false, false, true, false]);\n    }\n    // docs:end:to_be_bits_example\n\n    #[test]\n    // docs:start:to_le_bits_example\n    fn test_to_le_bits() {\n        let field = 2;\n        let bits: [bool; 8] = field.to_le_bits();\n        assert_eq(bits, [false, true, false, false, false, false, false, false]);\n    }\n    // docs:end:to_le_bits_example\n\n    #[test]\n    // docs:start:to_be_bytes_example\n    fn test_to_be_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_be_bytes();\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 0, 2]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_bytes_example\n\n    #[test]\n    // docs:start:to_le_bytes_example\n    fn test_to_le_bytes() {\n        let field = 2;\n        let bytes: [u8; 8] = field.to_le_bytes();\n        assert_eq(bytes, [2, 0, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_bytes_example\n\n    #[test]\n    // docs:start:to_be_radix_example\n    fn test_to_be_radix() {\n        // 259, in base 256, big endian, is [1, 3].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_be_radix(256);\n        assert_eq(bytes, [0, 0, 0, 0, 0, 0, 1, 3]);\n        assert_eq(Field::from_be_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_be_radix_example\n\n    #[test]\n    // docs:start:to_le_radix_example\n    fn test_to_le_radix() {\n        // 259, in base 256, little endian, is [3, 1].\n        // i.e. 3 * 256^0 + 1 * 256^1\n        let field = 259;\n\n        // The radix (in this example, 256) must be a power of 2.\n        // The length of the returned byte array can be specified to be\n        // >= the amount of space needed.\n        let bytes: [u8; 8] = field.to_le_radix(256);\n        assert_eq(bytes, [3, 1, 0, 0, 0, 0, 0, 0]);\n        assert_eq(Field::from_le_bytes::<8>(bytes), field);\n    }\n    // docs:end:to_le_radix_example\n\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    // Updated test to account for Brillig restriction that radix must be greater than 2\n    #[test(should_fail_with = \"radix must be greater than 1\")]\n    fn test_to_le_radix_brillig_1() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 1;\n            let _: [u8; 8] = field.to_le_radix(1);\n        } else {\n            panic(\"radix must be greater than 1\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be a power of 2\")]\n    fn test_to_le_radix_3() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(3);\n        } else {\n            panic(\"radix must be a power of 2\");\n        }\n    }\n\n    #[test]\n    fn test_to_le_radix_brillig_3() {\n        // this test should only fail in constrained mode\n        if runtime::is_unconstrained() {\n            let field = 1;\n            let out: [u8; 8] = field.to_le_radix(3);\n            let mut expected = [0; 8];\n            expected[0] = 1;\n            assert(out == expected, \"unexpected result\");\n        }\n    }\n\n    #[test(should_fail_with = \"radix must be less than or equal to 256\")]\n    fn test_to_le_radix_512() {\n        // this test should only fail in constrained mode\n        if !runtime::is_unconstrained() {\n            let field = 2;\n            let _: [u8; 8] = field.to_le_radix(512);\n        } else {\n            panic(\"radix must be less than or equal to 256\")\n        }\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    unconstrained fn not_enough_limbs_brillig() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 16 limbs\")]\n    fn not_enough_limbs() {\n        let _: [u8; 16] = 0x100000000000000000000000000000000.to_le_bytes();\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[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 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": [
@@ -672,31 +880,63 @@
           "name": "<impl Hash for [T]>::hash",
           "start": 8103
         },
+        {
+          "name": "<impl Hash for (A,)>::hash",
+          "start": 8325
+        },
         {
           "name": "<impl Hash for (A, B)>::hash",
-          "start": 8343
+          "start": 8494
         },
         {
           "name": "<impl Hash for (A, B, C)>::hash",
-          "start": 8559
+          "start": 8710
         },
         {
           "name": "<impl Hash for (A, B, C, D)>::hash",
-          "start": 8822
+          "start": 8973
         },
         {
           "name": "<impl Hash for (A, B, C, D, E)>::hash",
-          "start": 9132
+          "start": 9283
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F)>::hash",
+          "start": 9640
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G)>::hash",
+          "start": 10044
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash",
+          "start": 10498
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash",
+          "start": 10999
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash",
+          "start": 11547
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash",
+          "start": 12142
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash",
+          "start": 12785
         },
         {
           "name": "assert_pedersen",
-          "start": 9528
+          "start": 13379
         }
       ],
       "path": "std/hash/mod.nr",
-      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, B> Hash for (A, B)\nwhere\n    A: Hash,\n    B: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n    }\n}\n\nimpl<A, B, C> Hash for (A, B, C)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n    }\n}\n\nimpl<A, B, C, D> Hash for (A, B, C, D)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n    }\n}\n\nimpl<A, B, C, D, E> Hash for (A, B, C, D, E)\nwhere\n    A: Hash,\n    B: Hash,\n    C: Hash,\n    D: Hash,\n    E: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.0.hash(state);\n        self.1.hash(state);\n        self.2.hash(state);\n        self.3.hash(state);\n        self.4.hash(state);\n    }\n}\n\n// Some test vectors for Pedersen hash and Pedersen Commitment.\n// They have been generated using the same functions so the tests are for now useless\n// but they will be useful when we switch to Noir implementation.\n#[test]\nfn assert_pedersen() {\n    assert_eq(\n        pedersen_hash_with_separator([1], 1),\n        0x1b3f4b1a83092a13d8d1a59f7acb62aba15e7002f4440f2275edb99ebbc2305f,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1], 1),\n        EmbeddedCurvePoint {\n            x: 0x054aa86a73cb8a34525e5bbed6e43ba1198e860f5f3950268f71df4591bde402,\n            y: 0x209dcfbf2cfb57f9f6046f44d71ac6faf87254afc7407c04eb621a6287cac126,\n        },\n    );\n\n    assert_eq(\n        pedersen_hash_with_separator([1, 2], 2),\n        0x26691c129448e9ace0c66d11f0a16d9014a9e8498ee78f4d69f0083168188255,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2], 2),\n        EmbeddedCurvePoint {\n            x: 0x2e2b3b191e49541fe468ec6877721d445dcaffe41728df0a0eafeb15e87b0753,\n            y: 0x2ff4482400ad3a6228be17a2af33e2bcdf41be04795f9782bd96efe7e24f8778,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3], 3),\n        0x0bc694b7a1f8d10d2d8987d07433f26bd616a2d351bc79a3c540d85b6206dbe4,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3], 3),\n        EmbeddedCurvePoint {\n            x: 0x1fee4e8cf8d2f527caa2684236b07c4b1bad7342c01b0f75e9a877a71827dc85,\n            y: 0x2f9fedb9a090697ab69bf04c8bc15f7385b3e4b68c849c1536e5ae15ff138fd1,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4], 4),\n        0xdae10fb32a8408521803905981a2b300d6a35e40e798743e9322b223a5eddc,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4], 4),\n        EmbeddedCurvePoint {\n            x: 0x07ae3e202811e1fca39c2d81eabe6f79183978e6f12be0d3b8eda095b79bdbc9,\n            y: 0x0afc6f892593db6fbba60f2da558517e279e0ae04f95758587760ba193145014,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5], 5),\n        0xfc375b062c4f4f0150f7100dfb8d9b72a6d28582dd9512390b0497cdad9c22,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5], 5),\n        EmbeddedCurvePoint {\n            x: 0x1754b12bd475a6984a1094b5109eeca9838f4f81ac89c5f0a41dbce53189bb29,\n            y: 0x2da030e3cfcdc7ddad80eaf2599df6692cae0717d4e9f7bfbee8d073d5d278f7,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6], 6),\n        0x1696ed13dc2730062a98ac9d8f9de0661bb98829c7582f699d0273b18c86a572,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6], 6),\n        EmbeddedCurvePoint {\n            x: 0x190f6c0e97ad83e1e28da22a98aae156da083c5a4100e929b77e750d3106a697,\n            y: 0x1f4b60f34ef91221a0b49756fa0705da93311a61af73d37a0c458877706616fb,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        0x128c0ff144fc66b6cb60eeac8a38e23da52992fc427b92397a7dffd71c45ede3,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7], 7),\n        EmbeddedCurvePoint {\n            x: 0x015441e9d29491b06563fac16fc76abf7a9534c715421d0de85d20dbe2965939,\n            y: 0x1d2575b0276f4e9087e6e07c2cb75aa1baafad127af4be5918ef8a2ef2fea8fc,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        0x2f960e117482044dfc99d12fece2ef6862fba9242be4846c7c9a3e854325a55c,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8], 8),\n        EmbeddedCurvePoint {\n            x: 0x1657737676968887fceb6dd516382ea13b3a2c557f509811cd86d5d1199bc443,\n            y: 0x1f39f0cb569040105fa1e2f156521e8b8e08261e635a2b210bdc94e8d6d65f77,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        0x0c96db0790602dcb166cc4699e2d306c479a76926b81c2cb2aaa92d249ec7be7,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9], 9),\n        EmbeddedCurvePoint {\n            x: 0x0a3ceae42d14914a432aa60ec7fded4af7dad7dd4acdbf2908452675ec67e06d,\n            y: 0xfc19761eaaf621ad4aec9a8b2e84a4eceffdba78f60f8b9391b0bd9345a2f2,\n        },\n    );\n    assert_eq(\n        pedersen_hash_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        0x2cd37505871bc460a62ea1e63c7fe51149df5d0801302cf1cbc48beb8dff7e94,\n    );\n    assert_eq(\n        pedersen_commitment_with_separator([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 10),\n        EmbeddedCurvePoint {\n            x: 0x2fb3f8b3d41ddde007c8c3c62550f9a9380ee546fcc639ffbb3fd30c8d8de30c,\n            y: 0x300783be23c446b11a4c0fabf6c91af148937cea15fcf5fb054abf7f752ee245,\n        },\n    );\n}\n"
+      "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"
     },
-    "171": {
+    "170": {
       "function_locations": [
         {
           "name": "DelayedPublicMutableValues<T, INITIAL_DELAY>::new",
@@ -716,17 +956,17 @@
         },
         {
           "name": "<impl Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>>::unpack",
-          "start": 5966
+          "start": 6457
         },
         {
           "name": "<impl Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>>::hash",
-          "start": 6265
+          "start": 6756
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/delayed_public_mutable/delayed_public_mutable_values.nr",
-      "source": "use crate::{\n    delayed_public_mutable::{\n        scheduled_delay_change::ScheduledDelayChange, scheduled_value_change::ScheduledValueChange,\n    },\n    hash::poseidon2_hash,\n    traits::{Hash, Packable},\n    utils::arrays,\n};\nuse std::meta::derive;\n\nmod test;\n\n/// DelayedPublicMutableValues is just a wrapper around ScheduledValueChange and ScheduledDelayChange that then allows us\n/// to wrap both of these values in WithHash. WithHash allows for efficient read of values in private.\n///\n/// Note that the WithHash optimization does not work in public (due to there being no unconstrained). But we also want\n/// to be able to read the values efficiently in public and we want to be able to read each value separately. Reading\n/// the values separately is tricky because ScheduledValueChange and ScheduledDelayChange are packed together (sdc and\n/// svc.timestamp_of_change are stored in the same slot). For that reason we expose `unpack_value_change` and\n/// `unpack_delay_change` functions that can be used to extract the values from the packed representation. This\n/// is \"hacky\" but there is no way around it.\n#[derive(Eq)]\npub struct DelayedPublicMutableValues<T, let INITIAL_DELAY: u64> {\n    pub svc: ScheduledValueChange<T>,\n    pub sdc: ScheduledDelayChange<INITIAL_DELAY>,\n}\n\nimpl<T, let INITIAL_DELAY: u64> DelayedPublicMutableValues<T, INITIAL_DELAY> {\n    pub fn new(svc: ScheduledValueChange<T>, sdc: ScheduledDelayChange<INITIAL_DELAY>) -> Self {\n        DelayedPublicMutableValues { svc, sdc }\n    }\n}\n\n/// Extracts a ScheduledValueChange struct from the packed representation of the full DelayedPublicMutable.\n/// TODO: impl the packable trait for ScheduledValueChange.\npub fn unpack_value_change<T, let M: u32>(packed: [Field; 2 * M + 1]) -> ScheduledValueChange<T>\nwhere\n    T: Packable<N = M>,\n{\n    let svc_pre_packed = arrays::subarray(packed, 1);\n    let svc_post_packed = arrays::subarray(packed, M + 1);\n\n    // We first cast to u32 as the timestamp_of_change is packed into the same field as the delay change and it\n    // occupies the first 32 bits of the field.\n    let timestamp_of_change = (packed[0] as u32) as u64;\n    ScheduledValueChange::new(\n        T::unpack(svc_pre_packed),\n        T::unpack(svc_post_packed),\n        timestamp_of_change,\n    )\n}\n\n/// Extracts a ScheduledDelayChange struct from 0th field of the packed representation of the full DelayedPublicMutable.\n/// This function expects to be called with just the first field of the packed representation, which contains sdc\n/// and svc timestamp_of_change. We'll discard the svc component.\npub fn unpack_delay_change<let INITIAL_DELAY: u64>(\n    packed: Field,\n) -> ScheduledDelayChange<INITIAL_DELAY> {\n    // This function expects to be called with just the first field of the packed representation, which contains sdc\n    // and svc timestamp_of_change. We'll discard the svc component.\n    let svc_timestamp_of_change = packed as u32;\n\n    let mut tmp = (packed - svc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_timestamp_of_change = tmp as u32;\n\n    tmp = (tmp - sdc_timestamp_of_change as Field) / TWO_POW_32;\n    let sdc_post_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_post_is_some as Field) / TWO_POW_8;\n    let sdc_post_inner = tmp as u32;\n\n    tmp = (tmp - sdc_post_inner as Field) / TWO_POW_32;\n    let sdc_pre_is_some = (tmp as u8) % 2 != 0;\n\n    tmp = (tmp - sdc_pre_is_some as Field) / TWO_POW_8;\n    let sdc_pre_inner = tmp as u32;\n\n    // Note that below we cast the values to u64 as that is the default type of timestamp in the system. Us packing\n    // the values as u32 is a tech debt that is not worth tackling.\n    ScheduledDelayChange {\n        pre: if sdc_pre_is_some {\n            Option::some(sdc_pre_inner as u64)\n        } else {\n            Option::none()\n        },\n        post: if sdc_post_is_some {\n            Option::some(sdc_post_inner as u64)\n        } else {\n            Option::none()\n        },\n        timestamp_of_change: sdc_timestamp_of_change as u64,\n    }\n}\n\n// Q: do these evaluate at comptime or runtime?\nglobal TWO_POW_32: Field = 2.pow_32(32);\nglobal TWO_POW_8: Field = 2.pow_32(8);\n\n// We pack to `2 * N + 1` fields because ScheduledValueChange contains T twice (hence `2 * N`) and we need one extra\n// field to store ScheduledDelayChange and the timestamp_of_change of ScheduledValueChange.\nimpl<T, let INITIAL_DELAY: u64> Packable for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    let N: u32 = 2 * <T as Packable>::N + 1;\n\n    fn pack(self) -> [Field; Self::N] {\n        let mut result = [0; Self::N];\n\n        // We pack sdc.pre, sdc.post, sdc.timestamp_of_change and svc.timestamp_of_change into a single field as follows:\n        // [ sdc.pre_inner: u32 | sdc.pre_is_some: u8 | sdc.post_inner: u32 | sdc.post_is_some: u8 | sdc.timestamp_of_change: u32 | svc.timestamp_of_change: u32 ]\n        // Note that the code below no longer works after 2106 as by that time the timestamp will overflow u32. This is a tech debt that is not worth tackling.\n        result[0] = self.svc.timestamp_of_change as Field\n            + ((self.sdc.timestamp_of_change as Field) * 2.pow_32(32))\n            + ((self.sdc.post.is_some() as Field) * 2.pow_32(64))\n            + ((self.sdc.post.unwrap_unchecked() as Field) * 2.pow_32(72))\n            + ((self.sdc.pre.is_some() as Field) * 2.pow_32(104))\n            + ((self.sdc.pre.unwrap_unchecked() as Field) * 2.pow_32(112));\n\n        // Pack the pre and post values from ScheduledValueChange\n        let svc_pre_packed = self.svc.pre.pack();\n        let svc_post_packed = self.svc.post.pack();\n        for i in 0..<T as Packable>::N {\n            result[i + 1] = svc_pre_packed[i];\n            result[i + 1 + <T as Packable>::N] = svc_post_packed[i];\n        }\n        result\n    }\n\n    // Note: inefficient if all you want to unpack is the svc; use unpack_value_change instead.\n    fn unpack(fields: [Field; Self::N]) -> Self {\n        let svc = unpack_value_change::<T, _>(fields);\n        let sdc = unpack_delay_change::<INITIAL_DELAY>(fields[0]);\n        Self::new(svc, sdc)\n    }\n}\n\nimpl<T, let INITIAL_DELAY: u64> Hash for DelayedPublicMutableValues<T, INITIAL_DELAY>\nwhere\n    T: Packable,\n{\n    fn hash(self) -> Field {\n        poseidon2_hash(self.pack())\n    }\n}\n"
+      "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"
     },
-    "174": {
+    "173": {
       "function_locations": [
         {
           "name": "ScheduledDelayChange<INITIAL_DELAY>::new",
@@ -760,7 +1000,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "176": {
+    "175": {
       "function_locations": [
         {
           "name": "ScheduledValueChange<T>::new",
@@ -798,7 +1038,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "179": {
+    "178": {
       "function_locations": [
         {
           "name": "sha256_to_field",
@@ -920,7 +1160,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/hash.nr",
       "source": "mod poseidon2_chunks;\n\nuse crate::{\n    abis::{\n        contract_class_function_leaf_preimage::ContractClassFunctionLeafPreimage,\n        function_selector::FunctionSelector, nullifier::Nullifier, private_log::PrivateLog,\n        transaction::tx_request::TxRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, DOM_SEP__NOTE_HASH_NONCE,\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD, DOM_SEP__SILOED_NOTE_HASH, DOM_SEP__SILOED_NULLIFIER,\n        DOM_SEP__UNIQUE_NOTE_HASH, FUNCTION_TREE_HEIGHT, NULL_MSG_SENDER_CONTRACT_ADDRESS,\n        TWO_POW_64,\n    },\n    merkle_tree::root_from_sibling_path,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    poseidon2::Poseidon2Sponge,\n    side_effect::{Counted, Scoped},\n    traits::{FromField, Hash, ToField},\n    utils::field::{field_from_bytes, field_from_bytes_32_trunc},\n};\n\npub use poseidon2_chunks::poseidon2_absorb_in_chunks_existing_sponge;\nuse poseidon2_chunks::poseidon2_absorb_in_chunks;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\n// TODO: refactor these into their own files: sha256, poseidon2, some protocol-specific hash computations, some merkle computations.\n\npub fn sha256_to_field<let N: u32>(bytes_to_hash: [u8; N]) -> Field {\n    let sha256_hashed = sha256::digest(bytes_to_hash);\n    let hash_in_a_field = field_from_bytes_32_trunc(sha256_hashed);\n\n    hash_in_a_field\n}\n\npub fn private_functions_root_from_siblings(\n    selector: FunctionSelector,\n    vk_hash: Field,\n    function_leaf_index: Field,\n    function_leaf_sibling_path: [Field; FUNCTION_TREE_HEIGHT],\n) -> Field {\n    let function_leaf_preimage = ContractClassFunctionLeafPreimage { selector, vk_hash };\n    let function_leaf = function_leaf_preimage.hash();\n    root_from_sibling_path(\n        function_leaf,\n        function_leaf_index,\n        function_leaf_sibling_path,\n    )\n}\n\n/// Siloing in the context of Aztec refers to the process of hashing a note hash with a contract address (this way\n/// the note hash is scoped to a specific contract). This is used to prevent intermingling of notes between contracts.\npub fn compute_siloed_note_hash(contract_address: AztecAddress, note_hash: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), note_hash],\n        DOM_SEP__SILOED_NOTE_HASH,\n    )\n}\n\n/// Computes unique, siloed note hashes from siloed note hashes.\n///\n/// The protocol injects uniqueness into every note_hash, so that every single note_hash in the\n/// tree is unique. This prevents faerie gold attacks, where a malicious sender could create\n/// two identical note_hashes for a recipient (meaning only one would be nullifiable in future).\n///\n/// Most privacy protocols will inject the note's leaf_index (its position in the Note Hashes Tree)\n/// into the note, but this requires the creator of a note to wait until their tx is included in\n/// a block to know the note's final note hash (the unique, siloed note hash), because inserting\n/// leaves into trees is the job of a block producer.\n///\n/// We took a different approach so that the creator of a note will know each note's unique, siloed\n/// note hash before broadcasting their tx to the network.\n/// (There was also a historical requirement relating to \"chained transactions\" -- a feature that\n/// Aztec Connect had to enable notes to be spent from distinct txs earlier in the same block,\n/// and hence before an archive block root had been established for that block -- but that feature\n/// was abandoned for the Aztec Network for having too many bad tradeoffs).\n///\n/// (\n///   Edit: it is no longer true that all final note_hashes will be known by the creator of a tx\n///   before they send it to the network. If a tx makes public function calls, then _revertible_\n///   note_hashes that are created in private will not be made unique in private by the Reset circuit,\n///   but will instead be made unique by the AVM, because the `note_index_in_tx` will not be known\n///   until the AVM has executed the public functions of the tx. (See an explanation in\n///   reset_output_composer.nr for why).\n///   For some such txs, the `note_index_in_tx` might still be predictable through simulation, but\n///   for txs whose public functions create a varying number of non-revertible notes (determined at\n///   runtime), the `note_index_in_tx` will not be deterministically derivable before submitting the\n///   tx to the network.\n/// )\n///\n/// We use the `first_nullifier` of a tx as a seed of uniqueness. We have a guarantee that there will\n/// always be at least one nullifier per tx, because the init circuit will create one if one isn't\n/// created naturally by any functions of the tx. (Search \"protocol_nullifier\").\n/// We combine the `first_nullifier` with the note's index (its position within this tx's new\n/// note_hashes array) (`note_index_in_tx`) to get a truly unique value to inject into a note, which\n/// we call a `note_nonce`.\npub fn compute_unique_note_hash(note_nonce: Field, siloed_note_hash: Field) -> Field {\n    let inputs = [note_nonce, siloed_note_hash];\n    poseidon2_hash_with_separator(inputs, DOM_SEP__UNIQUE_NOTE_HASH)\n}\n\npub fn compute_note_hash_nonce(first_nullifier_in_tx: Field, note_index_in_tx: u32) -> Field {\n    // Hashing the first nullifier with note index in tx is guaranteed to be unique (because all nullifiers are also\n    // unique).\n    poseidon2_hash_with_separator(\n        [first_nullifier_in_tx, note_index_in_tx as Field],\n        DOM_SEP__NOTE_HASH_NONCE,\n    )\n}\n\npub fn compute_note_nonce_and_unique_note_hash(\n    siloed_note_hash: Field,\n    first_nullifier: Field,\n    note_index_in_tx: u32,\n) -> Field {\n    let note_nonce = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    compute_unique_note_hash(note_nonce, siloed_note_hash)\n}\n\npub fn compute_siloed_nullifier(contract_address: AztecAddress, nullifier: Field) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), nullifier],\n        DOM_SEP__SILOED_NULLIFIER,\n    )\n}\n\npub fn create_protocol_nullifier(tx_request: TxRequest) -> Scoped<Counted<Nullifier>> {\n    // The protocol nullifier is ascribed a special side-effect counter of 1. No other side-effect\n    // can have counter 1 (see `validate_as_first_call` for that assertion).\n    Nullifier { value: tx_request.hash(), note_hash: 0 }.count(1).scope(\n        NULL_MSG_SENDER_CONTRACT_ADDRESS,\n    )\n}\n\npub fn compute_log_tag(raw_tag: Field, dom_sep: u32) -> Field {\n    poseidon2_hash_with_separator([raw_tag], dom_sep)\n}\n\npub fn compute_siloed_private_log_first_field(\n    contract_address: AztecAddress,\n    field: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [contract_address.to_field(), field],\n        DOM_SEP__PRIVATE_LOG_FIRST_FIELD,\n    )\n}\n\npub fn compute_siloed_private_log(contract_address: AztecAddress, log: PrivateLog) -> PrivateLog {\n    let mut fields = log.fields;\n    fields[0] = compute_siloed_private_log_first_field(contract_address, fields[0]);\n    PrivateLog::new(fields, log.length)\n}\n\npub fn compute_contract_class_log_hash(log: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS]) -> Field {\n    poseidon2_hash(log)\n}\n\npub fn compute_app_siloed_secret_key(\n    master_secret_key: EmbeddedCurveScalar,\n    app_address: AztecAddress,\n    key_type_domain_separator: Field,\n) -> Field {\n    poseidon2_hash_with_separator(\n        [master_secret_key.hi, master_secret_key.lo, app_address.to_field()],\n        key_type_domain_separator,\n    )\n}\n\npub fn compute_l2_to_l1_message_hash(\n    message: Scoped<L2ToL1Message>,\n    rollup_version_id: Field,\n    chain_id: Field,\n) -> Field {\n    let contract_address_bytes: [u8; 32] = message.contract_address.to_field().to_be_bytes();\n    let recipient_bytes: [u8; 20] = message.inner.recipient.to_be_bytes();\n    let content_bytes: [u8; 32] = message.inner.content.to_be_bytes();\n    let rollup_version_id_bytes: [u8; 32] = rollup_version_id.to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n\n    let mut bytes: [u8; 148] = std::mem::zeroed();\n    for i in 0..32 {\n        bytes[i] = contract_address_bytes[i];\n        bytes[i + 32] = rollup_version_id_bytes[i];\n        // 64 - 84 are for recipient.\n        bytes[i + 84] = chain_id_bytes[i];\n        bytes[i + 116] = content_bytes[i];\n    }\n\n    for i in 0..20 {\n        bytes[64 + i] = recipient_bytes[i];\n    }\n\n    sha256_to_field(bytes)\n}\n\n// TODO: consider a variant that enables domain separation with a u32 (we seem to have standardised u32s for domain separators)\n/// Computes sha256 hash of 2 input fields.\n///\n/// @returns A truncated field (i.e., the first byte is always 0).\npub fn accumulate_sha256(v0: Field, v1: Field) -> Field {\n    // Concatenate two fields into 32 x 2 = 64 bytes\n    let v0_as_bytes: [u8; 32] = v0.to_be_bytes();\n    let v1_as_bytes: [u8; 32] = v1.to_be_bytes();\n    let hash_input_flattened = v0_as_bytes.concat(v1_as_bytes);\n\n    sha256_to_field(hash_input_flattened)\n}\n\npub fn poseidon2_hash<let N: u32>(inputs: [Field; N]) -> Field {\n    poseidon::poseidon2::Poseidon2::hash(inputs, N)\n}\n\n#[no_predicates]\npub fn poseidon2_hash_with_separator<let N: u32, T>(inputs: [Field; N], separator: T) -> Field\nwhere\n    T: ToField,\n{\n    let inputs_with_separator = [separator.to_field()].concat(inputs);\n    poseidon2_hash(inputs_with_separator)\n}\n\n/// Computes a Poseidon2 hash over a dynamic-length subarray of the given input.\n/// Only the first `in_len` fields of `input` are absorbed; any remaining fields are ignored.\n/// The caller is responsible for ensuring that the input is padded with zeros if required.\n#[no_predicates]\npub fn poseidon2_hash_subarray<let N: u32>(input: [Field; N], in_len: u32) -> Field {\n    let mut sponge = poseidon2_absorb_in_chunks(input, in_len);\n    sponge.squeeze()\n}\n\n// This function is  unconstrained because it is intended to be used in unconstrained context only as\n// in constrained contexts it would be too inefficient.\npub unconstrained fn poseidon2_hash_with_separator_bounded_vec<let N: u32, T>(\n    inputs: BoundedVec<Field, N>,\n    separator: T,\n) -> Field\nwhere\n    T: ToField,\n{\n    let in_len = inputs.len() + 1;\n    let iv: Field = (in_len as Field) * TWO_POW_64;\n    let mut sponge = Poseidon2Sponge::new(iv);\n    sponge.absorb(separator.to_field());\n\n    for i in 0..inputs.len() {\n        sponge.absorb(inputs.get(i));\n    }\n\n    sponge.squeeze()\n}\n\n#[no_predicates]\npub fn poseidon2_hash_bytes<let N: u32>(inputs: [u8; N]) -> Field {\n    let mut fields = [0; (N + 30) / 31];\n    let mut field_index = 0;\n    let mut current_field = [0; 31];\n    for i in 0..inputs.len() {\n        let index = i % 31;\n        current_field[index] = inputs[i];\n        if index == 30 {\n            fields[field_index] = field_from_bytes(current_field, false);\n            current_field = [0; 31];\n            field_index += 1;\n        }\n    }\n    if field_index != fields.len() {\n        fields[field_index] = field_from_bytes(current_field, false);\n    }\n    poseidon2_hash(fields)\n}\n\n#[test]\nfn subarray_hash_matches_fixed() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash the entire values_to_hash.\n    let fixed_len_hash = poseidon::poseidon2::Poseidon2::hash(values_to_hash, values_to_hash.len());\n\n    assert_eq(subarray_hash, fixed_len_hash);\n}\n\n#[test]\nfn subarray_hash_matches_variable() {\n    let values_to_hash = [3; 17];\n    let padded = values_to_hash.concat([0; 11]);\n    let subarray_hash = poseidon2_hash_subarray(padded, values_to_hash.len());\n\n    // Hash up to values_to_hash.len() fields of the padded array.\n    let variable_len_hash = poseidon::poseidon2::Poseidon2::hash(padded, values_to_hash.len());\n\n    assert_eq(subarray_hash, variable_len_hash);\n}\n\n#[test]\nfn smoke_sha256_to_field() {\n    let full_buffer = [\n        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,\n        25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,\n        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70,\n        71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,\n        94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,\n        113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130,\n        131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148,\n        149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,\n    ];\n    let result = sha256_to_field(full_buffer);\n\n    assert(result == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184c7);\n\n    // to show correctness of the current ver (truncate one byte) vs old ver (mod full bytes):\n    let result_bytes = sha256::digest(full_buffer);\n    let truncated_field = crate::utils::field::field_from_bytes_32_trunc(result_bytes);\n    assert(truncated_field == result);\n    let mod_res = result + (result_bytes[31] as Field);\n    assert(mod_res == 0x448ebbc9e1a31220a2f3830c18eef61b9bd070e5084b7fa2a359fe729184e0);\n}\n\n#[test]\nfn unique_siloed_note_hash_matches_typescript() {\n    let inner_note_hash = 1;\n    let contract_address = AztecAddress::from_field(2);\n    let first_nullifier = 3;\n    let note_index_in_tx = 4;\n\n    let siloed_note_hash = compute_siloed_note_hash(contract_address, inner_note_hash);\n    let siloed_note_hash_from_ts =\n        0x1986a4bea3eddb1fff917d629a13e10f63f514f401bdd61838c6b475db949169;\n    assert_eq(siloed_note_hash, siloed_note_hash_from_ts);\n\n    let nonce: Field = compute_note_hash_nonce(first_nullifier, note_index_in_tx);\n    let note_hash_nonce_from_ts =\n        0x28e7799791bf066a57bb51fdd0fbcaf3f0926414314c7db515ea343f44f5d58b;\n    assert_eq(nonce, note_hash_nonce_from_ts);\n\n    let unique_siloed_note_hash_from_nonce = compute_unique_note_hash(nonce, siloed_note_hash);\n    let unique_siloed_note_hash = compute_note_nonce_and_unique_note_hash(\n        siloed_note_hash,\n        first_nullifier,\n        note_index_in_tx,\n    );\n    assert_eq(unique_siloed_note_hash_from_nonce, unique_siloed_note_hash);\n\n    let unique_siloed_note_hash_from_ts =\n        0x29949aef207b715303b24639737c17fbfeb375c1d965ecfa85c7e4f0febb7d16;\n    assert_eq(unique_siloed_note_hash, unique_siloed_note_hash_from_ts);\n}\n\n#[test]\nfn siloed_nullifier_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let nullifier = 456;\n\n    let res = compute_siloed_nullifier(contract_address, nullifier);\n\n    let siloed_nullifier_from_ts =\n        0x169b50336c1f29afdb8a03d955a81e485f5ac7d5f0b8065673d1e407e5877813;\n\n    assert_eq(res, siloed_nullifier_from_ts);\n}\n\n#[test]\nfn siloed_private_log_first_field_matches_typescript() {\n    let contract_address = AztecAddress::from_field(123);\n    let field = 456;\n    let res = compute_siloed_private_log_first_field(contract_address, field);\n\n    let siloed_private_log_first_field_from_ts =\n        0x29480984f7b9257fded523d50addbcfc8d1d33adcf2db73ef3390a8fd5cdffaa;\n\n    assert_eq(res, siloed_private_log_first_field_from_ts);\n}\n\n#[test]\nfn empty_l2_to_l1_message_hash_matches_typescript() {\n    // All zeroes\n    let res = compute_l2_to_l1_message_hash(\n        L2ToL1Message { recipient: EthAddress::zero(), content: 0 }.scope(AztecAddress::from_field(\n            0,\n        )),\n        0,\n        0,\n    );\n\n    let empty_l2_to_l1_msg_hash_from_ts =\n        0x003b18c58c739716e76429634a61375c45b3b5cd470c22ab6d3e14cee23dd992;\n\n    assert_eq(res, empty_l2_to_l1_msg_hash_from_ts);\n}\n\n#[test]\nfn l2_to_l1_message_hash_matches_typescript() {\n    let message = L2ToL1Message { recipient: EthAddress::from_field(1), content: 2 }.scope(\n        AztecAddress::from_field(3),\n    );\n    let version = 4;\n    let chainId = 5;\n\n    let hash = compute_l2_to_l1_message_hash(message, version, chainId);\n\n    // The following value was generated by `yarn-project/stdlib/src/hash/hash.test.ts`\n    let l2_to_l1_message_hash_from_ts =\n        0x0081edf209e087ad31b3fd24263698723d57190bd1d6e9fe056fc0c0a68ee661;\n\n    assert_eq(hash, l2_to_l1_message_hash_from_ts);\n}\n\n#[test]\nunconstrained fn poseidon2_hash_with_separator_bounded_vec_matches_non_bounded_vec_version() {\n    let inputs = BoundedVec::<Field, 4>::from_array([1, 2, 3]);\n    let separator = 42;\n\n    // Hash using bounded vec version\n    let bounded_result = poseidon2_hash_with_separator_bounded_vec(inputs, separator);\n\n    // Hash using regular version\n    let regular_result = poseidon2_hash_with_separator([1, 2, 3], separator);\n\n    // Results should match\n    assert_eq(bounded_result, regular_result);\n}\n"
     },
-    "181": {
+    "180": {
       "function_locations": [
         {
           "name": "fatal_log",
@@ -988,13 +1228,13 @@
         },
         {
           "name": "log_oracle",
-          "start": 2801
+          "start": 2802
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/logging.nr",
-      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_utl_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
+      "source": "// Log levels matching the JS logger:\n\n// global SILENT_LOG_LEVEL: u8 = 0;\nglobal FATAL_LOG_LEVEL: u8 = 1;\nglobal ERROR_LOG_LEVEL: u8 = 2;\nglobal WARN_LOG_LEVEL: u8 = 3;\nglobal INFO_LOG_LEVEL: u8 = 4;\nglobal VERBOSE_LOG_LEVEL: u8 = 5;\nglobal DEBUG_LOG_LEVEL: u8 = 6;\nglobal TRACE_LOG_LEVEL: u8 = 7;\n\n// --- Per-level log functions (no format args) ---\n\npub fn fatal_log<let N: u32>(msg: str<N>) {\n    fatal_log_format(msg, []);\n}\n\npub fn error_log<let N: u32>(msg: str<N>) {\n    error_log_format(msg, []);\n}\n\npub fn warn_log<let N: u32>(msg: str<N>) {\n    warn_log_format(msg, []);\n}\n\npub fn info_log<let N: u32>(msg: str<N>) {\n    info_log_format(msg, []);\n}\n\npub fn verbose_log<let N: u32>(msg: str<N>) {\n    verbose_log_format(msg, []);\n}\n\npub fn debug_log<let N: u32>(msg: str<N>) {\n    debug_log_format(msg, []);\n}\n\npub fn trace_log<let N: u32>(msg: str<N>) {\n    trace_log_format(msg, []);\n}\n\n// --- Per-level log functions (with format args) ---\n\npub fn fatal_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(FATAL_LOG_LEVEL, msg, args);\n}\n\npub fn error_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(ERROR_LOG_LEVEL, msg, args);\n}\n\npub fn warn_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(WARN_LOG_LEVEL, msg, args);\n}\n\npub fn info_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(INFO_LOG_LEVEL, msg, args);\n}\n\npub fn verbose_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(VERBOSE_LOG_LEVEL, msg, args);\n}\n\npub fn debug_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(DEBUG_LOG_LEVEL, msg, args);\n}\n\npub fn trace_log_format<let M: u32, let N: u32>(msg: str<M>, args: [Field; N]) {\n    log_format(TRACE_LOG_LEVEL, msg, args);\n}\n\nfn log_format<let M: u32, let N: u32>(log_level: u8, msg: str<M>, args: [Field; N]) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe\n    // to call.\n    unsafe { log_oracle_wrapper(log_level, msg, args) };\n}\n\nunconstrained fn log_oracle_wrapper<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    args: [Field; N],\n) {\n    log_oracle(log_level, msg, N, args);\n}\n\n// While the length parameter might seem unnecessary given that we have N, we keep it around because at the AVM\n// bytecode level we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally\n// take that route. The AVM transpiler maps this oracle to the DEBUGLOG opcode, which reads the fields size from memory.\n#[oracle(aztec_misc_log)]\nunconstrained fn log_oracle<let M: u32, let N: u32>(\n    log_level: u8,\n    msg: str<M>,\n    length: u32,\n    args: [Field; N],\n) {}\n"
     },
-    "199": {
+    "198": {
       "function_locations": [
         {
           "name": "validate_on_curve",
@@ -1004,7 +1244,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "207": {
+    "206": {
       "function_locations": [
         {
           "name": "hash_public_key",
@@ -1040,41 +1280,41 @@
         },
         {
           "name": "test::default_hashes_match_default_points",
-          "start": 4552
+          "start": 4538
         },
         {
           "name": "test::compute_public_keys_hash",
-          "start": 5465
+          "start": 5437
         },
         {
           "name": "test::test_validate_on_curve",
-          "start": 6012
+          "start": 5970
         },
         {
           "name": "test::test_validate_not_on_curve",
-          "start": 6419
+          "start": 6363
         },
         {
           "name": "test::test_validate_non_infinity",
-          "start": 6778
+          "start": 6708
         },
         {
           "name": "test::test_validate_infinity",
-          "start": 7197
+          "start": 7113
         },
         {
           "name": "test::compute_default_hash",
-          "start": 7560
+          "start": 7462
         },
         {
           "name": "test::serde",
-          "start": 7868
+          "start": 7756
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/public_keys.nr",
-      "source": "use crate::{\n    address::public_keys_hash::PublicKeysHash,\n    constants::{\n        DEFAULT_FBPK_M_HASH, DEFAULT_IVPK_M_X, DEFAULT_IVPK_M_Y, DEFAULT_MSPK_M_HASH,\n        DEFAULT_NPK_M_HASH, DEFAULT_OVPK_M_HASH, DEFAULT_TPK_M_HASH, DOM_SEP__PUBLIC_KEYS_HASH,\n        DOM_SEP__SINGLE_PUBLIC_KEY_HASH,\n    },\n    hash::poseidon2_hash_with_separator,\n    point::{EmbeddedCurvePoint, validate_on_curve},\n    traits::{Deserialize, Hash, Serialize},\n};\n\nuse std::{default::Default, meta::derive};\n\npub trait ToPoint {\n    fn to_point(self) -> EmbeddedCurvePoint;\n}\n\n/// Hashes a public key point under the canonical single-public-key domain separator.\n///\n/// Defined as `Poseidon2(DOM_SEP__SINGLE_PUBLIC_KEY_HASH, x, y)`.\npub fn hash_public_key(p: EmbeddedCurvePoint) -> Field {\n    poseidon2_hash_with_separator([p.x, p.y], DOM_SEP__SINGLE_PUBLIC_KEY_HASH as Field)\n}\n\n#[derive(Deserialize, Eq, Serialize)]\npub struct IvpkM {\n    pub inner: EmbeddedCurvePoint,\n}\n\nimpl ToPoint for IvpkM {\n    fn to_point(self) -> EmbeddedCurvePoint {\n        self.inner\n    }\n}\n\nimpl Hash for IvpkM {\n    fn hash(self) -> Field {\n        hash_public_key(self.inner)\n    }\n}\n\n/// A non-owner's view of an account's master public keys.\n///\n/// `npk_m_hash`, `ovpk_m_hash`, `tpk_m_hash`, `mspk_m_hash`, and `fbpk_m_hash` are the\n/// [`hash_public_key`] digests of the underlying points. The points themselves are not exposed\n/// here - they are only known to the owner. `ivpk_m` remains a point because address derivation\n/// (encrypt-to-address) requires the raw point in-circuit.\n#[derive(Deserialize, Eq, Serialize)]\npub struct PublicKeys {\n    pub npk_m_hash: Field,\n    pub ivpk_m: IvpkM,\n    pub ovpk_m_hash: Field,\n    pub tpk_m_hash: Field,\n    pub mspk_m_hash: Field,\n    pub fbpk_m_hash: Field,\n}\n\nimpl Default for PublicKeys {\n    fn default() -> Self {\n        PublicKeys {\n            npk_m_hash: DEFAULT_NPK_M_HASH,\n            ivpk_m: IvpkM {\n                inner: EmbeddedCurvePoint { x: DEFAULT_IVPK_M_X, y: DEFAULT_IVPK_M_Y },\n            },\n            ovpk_m_hash: DEFAULT_OVPK_M_HASH,\n            tpk_m_hash: DEFAULT_TPK_M_HASH,\n            mspk_m_hash: DEFAULT_MSPK_M_HASH,\n            fbpk_m_hash: DEFAULT_FBPK_M_HASH,\n        }\n    }\n}\n\nimpl PublicKeys {\n    pub fn hash(self) -> PublicKeysHash {\n        PublicKeysHash::from_field(poseidon2_hash_with_separator(\n            [\n                self.npk_m_hash,\n                self.ivpk_m.hash(),\n                self.ovpk_m_hash,\n                self.tpk_m_hash,\n                self.mspk_m_hash,\n                self.fbpk_m_hash,\n            ],\n            DOM_SEP__PUBLIC_KEYS_HASH as Field,\n        ))\n    }\n\n    /// Validates that the (only) point-form key, `ivpk_m`, lies on the Grumpkin curve.\n    ///\n    /// The other five keys are exposed only as hashes and are unverifiable on-circuit; the PXE\n    /// is responsible for ensuring they were derived from on-curve points before persistence.\n    pub fn validate_on_curve(self) {\n        validate_on_curve(self.ivpk_m.inner);\n    }\n\n    /// Validates that `ivpk_m` is not the point at infinity.\n    ///\n    /// As with [`Self::validate_on_curve`], the other five keys are now exposed only as hashes\n    /// and this property must be enforced PXE-side.\n    pub fn validate_non_infinity(self) {\n        assert_eq(self.ivpk_m.inner.is_infinite(), false, \"IvpkM is the point at infinity\");\n    }\n}\n\npub struct AddressPoint {\n    pub inner: EmbeddedCurvePoint,\n}\n\nimpl ToPoint for AddressPoint {\n    fn to_point(self) -> EmbeddedCurvePoint {\n        self.inner\n    }\n}\n\nmod test {\n    use crate::constants::{\n        DEFAULT_FBPK_M_HASH, DEFAULT_FBPK_M_X, DEFAULT_FBPK_M_Y, DEFAULT_MSPK_M_HASH,\n        DEFAULT_MSPK_M_X, DEFAULT_MSPK_M_Y, DEFAULT_NPK_M_HASH, DEFAULT_NPK_M_X, DEFAULT_NPK_M_Y,\n        DEFAULT_OVPK_M_HASH, DEFAULT_OVPK_M_X, DEFAULT_OVPK_M_Y, DEFAULT_TPK_M_HASH,\n        DEFAULT_TPK_M_X, DEFAULT_TPK_M_Y,\n    };\n    use crate::{\n        point::EmbeddedCurvePoint,\n        public_keys::{hash_public_key, IvpkM, PublicKeys},\n        traits::{Deserialize, Serialize},\n    };\n\n    global PUBLIC_KEYS_LENGTH: u32 = 7;\n\n    /// Catches drift between the precomputed `DEFAULT_*_M_HASH` constants and the\n    /// `DEFAULT_*_M_X/Y` curve points they're derived from. If anyone updates the X/Y\n    /// constants (or the hashing primitive) without also updating the *_HASH constants,\n    /// this test fails and `PublicKeys::default()` would silently produce a stale value.\n    #[test]\n    unconstrained fn default_hashes_match_default_points() {\n        let npk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_NPK_M_X, y: DEFAULT_NPK_M_Y },\n        );\n        assert_eq(npk, DEFAULT_NPK_M_HASH);\n\n        let ovpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_OVPK_M_X, y: DEFAULT_OVPK_M_Y },\n        );\n        assert_eq(ovpk, DEFAULT_OVPK_M_HASH);\n\n        let tpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_TPK_M_X, y: DEFAULT_TPK_M_Y },\n        );\n        assert_eq(tpk, DEFAULT_TPK_M_HASH);\n\n        let mspk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_MSPK_M_X, y: DEFAULT_MSPK_M_Y },\n        );\n        assert_eq(mspk, DEFAULT_MSPK_M_HASH);\n\n        let fbpk = hash_public_key(\n            EmbeddedCurvePoint { x: DEFAULT_FBPK_M_X, y: DEFAULT_FBPK_M_Y },\n        );\n        assert_eq(fbpk, DEFAULT_FBPK_M_HASH);\n    }\n\n    #[test]\n    unconstrained fn compute_public_keys_hash() {\n        let keys = PublicKeys {\n            npk_m_hash: 11,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 22,\n            tpk_m_hash: 33,\n            mspk_m_hash: 44,\n            fbpk_m_hash: 55,\n        };\n\n        let actual = keys.hash().to_field();\n\n        let expected_public_keys_hash =\n            0x1e57c605207e2b607720b8e3023f69f5af25683277db5ff3b99f7948213c7878;\n\n        assert_eq(actual, expected_public_keys_hash);\n    }\n\n    #[test]\n    unconstrained fn test_validate_on_curve() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::generator().double() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_on_curve();\n    }\n\n    #[test(should_fail_with = \"Point not on curve\")]\n    unconstrained fn test_validate_not_on_curve() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_on_curve();\n    }\n\n    #[test]\n    unconstrained fn test_validate_non_infinity() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::generator().double() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test(should_fail_with = \"IvpkM is the point at infinity\")]\n    unconstrained fn test_validate_infinity() {\n        let keys = PublicKeys {\n            npk_m_hash: 0,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint::point_at_infinity() },\n            ovpk_m_hash: 0,\n            tpk_m_hash: 0,\n            mspk_m_hash: 0,\n            fbpk_m_hash: 0,\n        };\n\n        keys.validate_non_infinity();\n    }\n\n    #[test]\n    unconstrained fn compute_default_hash() {\n        let keys = PublicKeys::default();\n\n        let actual = keys.hash().to_field();\n\n        let test_data_default_hash =\n            0x13c13fbec22a396f700180c621fb8c67b830b431fed47d4dd71a20d828829eaa;\n\n        assert_eq(actual, test_data_default_hash);\n    }\n\n    #[test]\n    unconstrained fn serde() {\n        let keys = PublicKeys {\n            npk_m_hash: 11,\n            ivpk_m: IvpkM { inner: EmbeddedCurvePoint { x: 3, y: 4 } },\n            ovpk_m_hash: 22,\n            tpk_m_hash: 33,\n            mspk_m_hash: 44,\n            fbpk_m_hash: 55,\n        };\n\n        let serialized: [Field; PUBLIC_KEYS_LENGTH] = keys.serialize();\n        let deserialized = PublicKeys::deserialize(serialized);\n\n        assert_eq(keys, deserialized);\n    }\n}\n"
+      "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"
     },
-    "212": {
+    "211": {
       "function_locations": [
         {
           "name": "derive_storage_slot_in_map",
@@ -1088,7 +1328,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/types/src/storage/map.nr",
       "source": "use crate::{\n    constants::DOM_SEP__PUBLIC_STORAGE_MAP_SLOT, hash::poseidon2_hash_with_separator,\n    traits::ToField,\n};\n\n// TODO: Move this to src/public_data/storage/map.nr\npub fn derive_storage_slot_in_map<K>(storage_slot: Field, key: K) -> Field\nwhere\n    K: ToField,\n{\n    poseidon2_hash_with_separator(\n        [storage_slot, key.to_field()],\n        DOM_SEP__PUBLIC_STORAGE_MAP_SLOT,\n    )\n}\n\nmod test {\n    use crate::{address::AztecAddress, storage::map::derive_storage_slot_in_map, traits::FromField};\n\n    #[test]\n    fn test_derive_storage_slot_in_map_matches_typescript() {\n        let map_slot = 0x132258fb6962c4387ba659d9556521102d227549a386d39f0b22d1890d59c2b5;\n        let key = AztecAddress::from_field(\n            0x302dbc2f9b50a73283d5fb2f35bc01eae8935615817a0b4219a057b2ba8a5a3f,\n        );\n\n        let slot = derive_storage_slot_in_map(map_slot, key);\n\n        // The following value was generated by `map_slot.test.ts`\n        let slot_from_typescript =\n            0x2d225f361108379adc2da91378b9702675c5546b57e78bafc1e74ec7fec55967;\n\n        assert_eq(slot, slot_from_typescript);\n    }\n}\n"
     },
-    "239": {
+    "238": {
       "function_locations": [
         {
           "name": "Poseidon2::hash",
@@ -1130,7 +1370,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"
     },
-    "242": {
+    "241": {
       "function_locations": [
         {
           "name": "Reader<N>::new",
@@ -1180,7 +1420,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "243": {
+    "242": {
       "function_locations": [
         {
           "name": "derive_serialize",
@@ -1188,25 +1428,25 @@
         },
         {
           "name": "derive_deserialize",
-          "start": 7206
+          "start": 7208
         },
         {
           "name": "get_params_len_quote",
-          "start": 10928
+          "start": 10934
         },
         {
           "name": "get_generics_declarations",
-          "start": 11387
+          "start": 11393
         },
         {
           "name": "get_where_trait_clause",
-          "start": 12469
+          "start": 12477
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
+      "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"
     },
-    "245": {
+    "244": {
       "function_locations": [
         {
           "name": "<impl Serialize for bool>::serialize",
@@ -1498,29 +1738,29 @@
         },
         {
           "name": "<impl Serialize for (T1,)>::serialize",
-          "start": 20158
+          "start": 20178
         },
         {
           "name": "<impl Serialize for (T1,)>::stream_serialize",
-          "start": 20409
+          "start": 20429
         },
         {
           "name": "<impl Deserialize for (T1,)>::deserialize",
-          "start": 20616
+          "start": 20636
         },
         {
           "name": "<impl Deserialize for (T1,)>::stream_deserialize",
-          "start": 20877
+          "start": 20897
         },
         {
           "name": "bounded_vec_serialization",
-          "start": 21226
+          "start": 21246
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-protocol-circuits/crates/serde/src/type_impls.nr",
-      "source": "use crate::{reader::Reader, serialization::{Deserialize, Serialize}, writer::Writer};\nuse std::embedded_curve_ops::EmbeddedCurvePoint;\nuse std::embedded_curve_ops::EmbeddedCurveScalar;\n\nglobal BOOL_SERIALIZED_LEN: u32 = 1;\nglobal U8_SERIALIZED_LEN: u32 = 1;\nglobal U16_SERIALIZED_LEN: u32 = 1;\nglobal U32_SERIALIZED_LEN: u32 = 1;\nglobal U64_SERIALIZED_LEN: u32 = 1;\nglobal U128_SERIALIZED_LEN: u32 = 1;\nglobal FIELD_SERIALIZED_LEN: u32 = 1;\nglobal I8_SERIALIZED_LEN: u32 = 1;\nglobal I16_SERIALIZED_LEN: u32 = 1;\nglobal I32_SERIALIZED_LEN: u32 = 1;\nglobal I64_SERIALIZED_LEN: u32 = 1;\n\nimpl Serialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for bool {\n    let N: u32 = BOOL_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> bool {\n        reader.read() != 0\n    }\n}\n\nimpl Serialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u8 {\n    let N: u32 = U8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8\n    }\n}\n\nimpl Serialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u16 {\n    let N: u32 = U16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16\n    }\n}\n\nimpl Serialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u32 {\n    let N: u32 = U32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32\n    }\n}\n\nimpl Serialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u64 {\n    let N: u32 = U64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64\n    }\n}\n\nimpl Serialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as Field);\n    }\n}\n\nimpl Deserialize for u128 {\n    let N: u32 = U128_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u128\n    }\n}\n\nimpl Serialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self);\n    }\n}\n\nimpl Deserialize for Field {\n    let N: u32 = FIELD_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read()\n    }\n}\n\nimpl Serialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u8 as Field);\n    }\n}\n\nimpl Deserialize for i8 {\n    let N: u32 = I8_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u8 as i8\n    }\n}\n\nimpl Serialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u16 as Field);\n    }\n}\n\nimpl Deserialize for i16 {\n    let N: u32 = I16_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u16 as i16\n    }\n}\n\nimpl Serialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u32 as Field);\n    }\n}\n\nimpl Deserialize for i32 {\n    let N: u32 = I32_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u32 as i32\n    }\n}\n\nimpl Serialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self as u64 as Field);\n    }\n}\n\nimpl Deserialize for i64 {\n    let N: u32 = I64_SERIALIZED_LEN;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        reader.read() as u64 as i64\n    }\n}\n\nimpl<T, let M: u32> Serialize for [T; M]\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        for i in 0..M {\n            self[i].stream_serialize(writer);\n        }\n    }\n}\n\nimpl<T, let M: u32> Deserialize for [T; M]\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut result: [T; M] = std::mem::zeroed();\n        for i in 0..M {\n            result[i] = T::stream_deserialize(reader);\n        }\n        result\n    }\n}\n\nimpl<T> Serialize for Option<T>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N + 1;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write_bool(self.is_some());\n        if self.is_some() {\n            self.unwrap_unchecked().stream_serialize(writer);\n        } else {\n            writer.advance_offset(<T as Serialize>::N);\n        }\n    }\n}\n\nimpl<T> Deserialize for Option<T>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        if reader.read_bool() {\n            Option::some(<T as Deserialize>::stream_deserialize(reader))\n        } else {\n            reader.advance_offset(<T as Deserialize>::N);\n            Option::none()\n        }\n    }\n}\n\nglobal SCALAR_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurveScalar {\n\n    let N: u32 = SCALAR_SIZE;\n\n    fn serialize(self) -> [Field; SCALAR_SIZE] {\n        [self.lo, self.hi]\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.lo);\n        writer.write(self.hi);\n    }\n}\n\nimpl Deserialize for EmbeddedCurveScalar {\n    let N: u32 = SCALAR_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { lo: fields[0], hi: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { lo: reader.read(), hi: reader.read() }\n    }\n}\n\nglobal POINT_SIZE: u32 = 2;\n\nimpl Serialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn serialize(self) -> [Field; Self::N] {\n        [self.x, self.y]\n    }\n\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        writer.write(self.x);\n        writer.write(self.y);\n    }\n}\n\nimpl Deserialize for EmbeddedCurvePoint {\n    let N: u32 = POINT_SIZE;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        Self { x: fields[0], y: fields[1] }\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        Self { x: reader.read(), y: reader.read() }\n    }\n}\n\nimpl<let M: u32> Deserialize for str<M> {\n    let N: u32 = M;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let u8_arr = <[u8; Self::N] as Deserialize>::stream_deserialize(reader);\n        str::<Self::N>::from(u8_arr)\n    }\n}\n\nimpl<let M: u32> Serialize for str<M> {\n    let N: u32 = M;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.as_bytes().stream_serialize(writer);\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Deserialize for BoundedVec<T, M>\nwhere\n    T: Deserialize,\n{\n    let N: u32 = <T as Deserialize>::N * M + 1;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        let mut new_bounded_vec: BoundedVec<T, M> = BoundedVec::new();\n        let payload_len = Self::N - 1;\n\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        let len = reader.peek_offset(payload_len) as u32;\n\n        for i in 0..M {\n            if i < len {\n                new_bounded_vec.push(<T as Deserialize>::stream_deserialize(reader));\n            }\n        }\n\n        // +1 for the length of the BoundedVec\n        reader.advance_offset((M - len) * <T as Deserialize>::N + 1);\n\n        new_bounded_vec\n    }\n}\n\n// This may cause issues if used as program input, because noir disallows empty arrays for program input.\n// I think this is okay because I don't foresee a unit type being used as input. But leaving this comment as a hint\n// if someone does run into this in the future.\nimpl Deserialize for () {\n    let N: u32 = 0;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(_reader: &mut Reader<K>) -> Self {\n        ()\n    }\n}\n\n// Note: Not deriving this because it's not supported to call derive_serialize on a \"remote\" struct (and it will never\n// be supported).\nimpl<T, let M: u32> Serialize for BoundedVec<T, M>\nwhere\n    T: Serialize,\n{\n    let N: u32 = <T as Serialize>::N * M + 1; // +1 for the length of the BoundedVec\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: Writer<Self::N> = Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.storage().stream_serialize(writer);\n        // Length is stored in the last field as we need to match intrinsic Noir serialization and the `len` struct\n        // field is after `storage` struct field (see `bounded_vec.nr` in noir-stdlib)\n        writer.write_u32(self.len() as u32);\n    }\n}\n\n// Create a slice of the given length with each element made from `f(i)` where `i` is the current index\ncomptime fn make_slice<Env, T>(length: u32, f: fn[Env](u32) -> T) -> [T] {\n    let mut slice = @[];\n    for i in 0..length {\n        slice = slice.push_back(f(i));\n    }\n    slice\n}\n\n// Implements Serialize and Deserialize for an arbitrary tuple type\ncomptime fn impl_serialize_for_tuple(_m: Module, length: u32) -> Quoted {\n    // `T0`, `T1`, `T2`\n    let type_names = make_slice(length, |i| f\"T{i}\".quoted_contents());\n\n    // `result0`, `result1`, `result2`\n    let result_names = make_slice(length, |i| f\"result{i}\".quoted_contents());\n\n    // `T0, T1, T2`\n    let field_generics = type_names.join(quote [,]);\n\n    // `<T0 as Serialize>::N + <T1 as Serialize>::N + <T2 as Serialize>::N`\n    let full_size_serialize = type_names\n        .map(|type_name| quote {\n        <$type_name as Serialize>::N\n    })\n        .join(quote [+]);\n\n    // `<T0 as Deserialize>::N + <T1 as Deserialize>::N + <T2 as Deserialize>::N`\n    let full_size_deserialize = type_names\n        .map(|type_name| quote {\n        <$type_name as Deserialize>::N\n    })\n        .join(quote [+]);\n\n    // `T0: Serialize, T1: Serialize, T2: Serialize,`\n    let serialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Serialize,\n    })\n        .join(quote []);\n\n    // `T0: Deserialize, T1: Deserialize, T2: Deserialize,`\n    let deserialize_constraints = type_names\n        .map(|field_name| quote {\n        $field_name: Deserialize,\n    })\n        .join(quote []);\n\n    // Statements to serialize each field\n    let serialized_fields = type_names\n        .mapi(|i, _type_name| quote {\n            $crate::serialization::Serialize::stream_serialize(self.$i, writer);\n    })\n        .join(quote []);\n\n    // Statements to deserialize each field\n    let deserialized_fields = type_names\n        .mapi(|i, type_name| {\n            let result_name = result_names[i];\n            quote {\n            let $result_name = <$type_name as $crate::serialization::Deserialize>::stream_deserialize(reader);\n        }\n        })\n        .join(quote []);\n    let deserialize_results = result_names.join(quote [,]);\n\n    quote {\n        impl<$field_generics> Serialize for ($field_generics) where $serialize_constraints {\n            let N: u32 = $full_size_serialize;\n\n            fn serialize(self) -> [Field; Self::N] {\n                let mut writer: $crate::writer::Writer<Self::N> = $crate::writer::Writer::new();\n                self.stream_serialize(&mut writer);\n                writer.finish()\n            }\n\n            #[inline_always]\n            fn stream_serialize<let K: u32>(self, writer: &mut $crate::writer::Writer<K>) {\n\n                $serialized_fields\n            }\n        }\n\n        impl<$field_generics> Deserialize for ($field_generics) where $deserialize_constraints {\n            let N: u32 = $full_size_deserialize;\n\n            fn deserialize(fields: [Field; Self::N]) -> Self {\n                let mut reader = $crate::reader::Reader::new(fields);\n                let result = Self::stream_deserialize(&mut reader);\n                reader.finish();\n                result\n            }\n    \n            #[inline_always]\n            fn stream_deserialize<let K: u32>(reader: &mut $crate::reader::Reader<K>) -> Self {\n                $deserialized_fields\n                ($deserialize_results)\n            }\n        }\n    }\n}\n\n// Keeping these manual impls. They are more efficient since they do not\n// require copying sub-arrays from any serialized arrays.\nimpl<T1> Serialize for (T1,)\nwhere\n    T1: Serialize,\n{\n    let N: u32 = <T1 as Serialize>::N;\n\n    fn serialize(self) -> [Field; Self::N] {\n        let mut writer: crate::writer::Writer<Self::N> = crate::writer::Writer::new();\n        self.stream_serialize(&mut writer);\n        writer.finish()\n    }\n\n    #[inline_always]\n    fn stream_serialize<let K: u32>(self, writer: &mut Writer<K>) {\n        self.0.stream_serialize(writer);\n    }\n}\n\nimpl<T1> Deserialize for (T1,)\nwhere\n    T1: Deserialize,\n{\n    let N: u32 = <T1 as Deserialize>::N;\n\n    fn deserialize(fields: [Field; Self::N]) -> Self {\n        let mut reader = crate::reader::Reader::new(fields);\n        let result = Self::stream_deserialize(&mut reader);\n        reader.finish();\n        result\n    }\n\n    #[inline_always]\n    fn stream_deserialize<let K: u32>(reader: &mut Reader<K>) -> Self {\n        (<T1 as Deserialize>::stream_deserialize(reader),)\n    }\n}\n\n#[impl_serialize_for_tuple(2)]\n#[impl_serialize_for_tuple(3)]\n#[impl_serialize_for_tuple(4)]\n#[impl_serialize_for_tuple(5)]\n#[impl_serialize_for_tuple(6)]\nmod impls {\n    use crate::serialization::{Deserialize, Serialize};\n}\n\n#[test]\nunconstrained fn bounded_vec_serialization() {\n    // Test empty BoundedVec\n    let empty_vec: BoundedVec<Field, 3> = BoundedVec::from_array([]);\n    let serialized = empty_vec.serialize();\n    let deserialized = BoundedVec::<Field, 3>::deserialize(serialized);\n    assert_eq(empty_vec, deserialized);\n    assert_eq(deserialized.len(), 0);\n\n    // Test partially filled BoundedVec\n    let partial_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2]]);\n    let serialized = partial_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(partial_vec, deserialized);\n    assert_eq(deserialized.len(), 1);\n    assert_eq(deserialized.get(0), [1, 2]);\n\n    // Test full BoundedVec\n    let full_vec: BoundedVec<[u32; 2], 3> = BoundedVec::from_array([[1, 2], [3, 4], [5, 6]]);\n    let serialized = full_vec.serialize();\n    let deserialized = BoundedVec::<[u32; 2], 3>::deserialize(serialized);\n    assert_eq(full_vec, deserialized);\n    assert_eq(deserialized.len(), 3);\n    assert_eq(deserialized.get(0), [1, 2]);\n    assert_eq(deserialized.get(1), [3, 4]);\n    assert_eq(deserialized.get(2), [5, 6]);\n}\n"
+      "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"
     },
-    "40": {
+    "42": {
       "function_locations": [
         {
           "name": "Option<T>::none",
@@ -1613,54 +1853,104 @@
         {
           "name": "<impl Ord for Option<T>>::cmp",
           "start": 5975
-        }
-      ],
-      "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"
-    },
-    "41": {
-      "function_locations": [
+        },
         {
-          "name": "panic",
-          "start": 196
-        }
-      ],
-      "path": "std/panic.nr",
-      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n"
-    },
-    "49": {
-      "function_locations": [
+          "name": "tests::some_and_none",
+          "start": 6447
+        },
         {
-          "name": "ContractInstanceRegistry::ContractInstancePublished::serialize_non_standard",
-          "start": 1995
+          "name": "tests::unwrap_succeeds",
+          "start": 6677
         },
         {
-          "name": "ContractInstanceRegistry::publish_for_public_execution",
-          "start": 5010
+          "name": "tests::unwrap_fails",
+          "start": 6781
         },
         {
-          "name": "ContractInstanceRegistry::update",
-          "start": 9119
+          "name": "tests::unwrap_or",
+          "start": 6868
         },
         {
-          "name": "ContractInstanceRegistry::set_update_delay",
-          "start": 11330
+          "name": "tests::unwrap_or_else",
+          "start": 7016
         },
         {
-          "name": "ContractInstanceRegistry::get_update_delay",
-          "start": 12633
+          "name": "tests::expect_succeeds",
+          "start": 7181
         },
         {
-          "name": "ContractInstanceRegistry::public_dispatch",
-          "start": 13785
+          "name": "tests::expect_fails",
+          "start": 7328
         },
         {
-          "name": "ContractInstanceRegistry::Storage<Context>::init",
-          "start": 14918
+          "name": "tests::map",
+          "start": 7427
+        },
+        {
+          "name": "tests::map_or",
+          "start": 7595
+        },
+        {
+          "name": "tests::map_or_else",
+          "start": 7762
+        },
+        {
+          "name": "tests::and",
+          "start": 7937
+        },
+        {
+          "name": "tests::and_then",
+          "start": 8277
+        },
+        {
+          "name": "tests::or",
+          "start": 8663
+        },
+        {
+          "name": "tests::or_else",
+          "start": 9000
+        },
+        {
+          "name": "tests::xor",
+          "start": 9365
+        },
+        {
+          "name": "tests::filter",
+          "start": 9704
+        },
+        {
+          "name": "tests::flatten",
+          "start": 10030
+        },
+        {
+          "name": "tests::default",
+          "start": 10301
+        },
+        {
+          "name": "tests::eq",
+          "start": 10394
+        },
+        {
+          "name": "tests::cmp",
+          "start": 10714
         }
       ],
-      "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": "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": {
+      "function_locations": [
+        {
+          "name": "panic",
+          "start": 196
+        },
+        {
+          "name": "tests::panics",
+          "start": 469
+        }
+      ],
+      "path": "std/panic.nr",
+      "source": "/// Halt the program at runtime with the given error message.\n///\n/// The provided error message must be either a `str` or a `fmtstr`.\npub fn panic<T, U>(message: T) -> U\nwhere\n    T: StringLike,\n{\n    assert(false, message);\n    crate::mem::zeroed()\n}\n\ntrait StringLike {}\n\nimpl<let N: u32> StringLike for str<N> {}\nimpl<let N: u32, T> StringLike for fmtstr<N, T> {}\n\nmod tests {\n    use crate::prelude::panic;\n\n    #[test(should_fail_with = \"OH NO\")]\n    fn panics() {\n        panic(\"OH NO\");\n    }\n}\n"
     },
     "5": {
       "function_locations": [
@@ -1732,197 +2022,279 @@
           "name": "make_tuple_eq_body",
           "start": 2598
         },
+        {
+          "name": "<impl Eq for (A,)>::eq",
+          "start": 2848
+        },
         {
           "name": "<impl Eq for (A, B)>::eq",
-          "start": 2859
+          "start": 2959
         },
         {
           "name": "<impl Eq for (A, B, C)>::eq",
-          "start": 2991
+          "start": 3091
         },
         {
           "name": "<impl Eq for (A, B, C, D)>::eq",
-          "start": 3136
+          "start": 3236
         },
         {
           "name": "<impl Eq for (A, B, C, D, E)>::eq",
-          "start": 3294
+          "start": 3394
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F)>::eq",
-          "start": 3465
+          "start": 3565
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G)>::eq",
-          "start": 3649
+          "start": 3749
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G, H)>::eq",
-          "start": 3846
+          "start": 3946
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G, H, I)>::eq",
-          "start": 4056
+          "start": 4156
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J)>::eq",
-          "start": 4279
+          "start": 4379
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J, K)>::eq",
-          "start": 4516
+          "start": 4616
         },
         {
           "name": "<impl Eq for (A, B, C, D, E, F, G, H, I, J, K, L)>::eq",
-          "start": 4766
+          "start": 4866
         },
         {
           "name": "<impl Eq for Ordering>::eq",
-          "start": 4876
+          "start": 4976
         },
         {
           "name": "Ordering::less",
-          "start": 5477
+          "start": 5577
         },
         {
           "name": "Ordering::equal",
-          "start": 5548
+          "start": 5648
         },
         {
           "name": "Ordering::greater",
-          "start": 5621
+          "start": 5721
         },
         {
           "name": "derive_ord",
-          "start": 5992
+          "start": 6092
         },
         {
           "name": "<impl Ord for u128>::cmp",
-          "start": 6642
+          "start": 6742
         },
         {
           "name": "<impl Ord for u64>::cmp",
-          "start": 6889
+          "start": 6989
         },
         {
           "name": "<impl Ord for u32>::cmp",
-          "start": 7137
+          "start": 7237
         },
         {
           "name": "<impl Ord for u16>::cmp",
-          "start": 7385
+          "start": 7485
         },
         {
           "name": "<impl Ord for u8>::cmp",
-          "start": 7631
+          "start": 7731
         },
         {
           "name": "<impl Ord for i8>::cmp",
-          "start": 7877
+          "start": 7977
         },
         {
           "name": "<impl Ord for i16>::cmp",
-          "start": 8125
+          "start": 8225
         },
         {
           "name": "<impl Ord for i32>::cmp",
-          "start": 8373
+          "start": 8473
         },
         {
           "name": "<impl Ord for i64>::cmp",
-          "start": 8621
+          "start": 8721
         },
         {
           "name": "<impl Ord for ()>::cmp",
-          "start": 8875
+          "start": 8975
         },
         {
           "name": "<impl Ord for bool>::cmp",
-          "start": 8974
+          "start": 9074
         },
         {
           "name": "<impl Ord for [T; N]>::cmp",
-          "start": 9444
+          "start": 9544
         },
         {
           "name": "<impl Ord for [T]>::cmp",
-          "start": 9847
+          "start": 9947
         },
         {
           "name": "make_tuple_ord_body",
-          "start": 10415
+          "start": 10515
+        },
+        {
+          "name": "<impl Ord for (A,)>::cmp",
+          "start": 11125
         },
         {
           "name": "<impl Ord for (A, B)>::cmp",
-          "start": 11037
+          "start": 11246
         },
         {
           "name": "<impl Ord for (A, B, C)>::cmp",
-          "start": 11179
+          "start": 11388
         },
         {
           "name": "<impl Ord for (A, B, C, D)>::cmp",
-          "start": 11335
+          "start": 11544
         },
         {
           "name": "<impl Ord for (A, B, C, D, E)>::cmp",
-          "start": 11505
+          "start": 11714
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F)>::cmp",
-          "start": 11689
+          "start": 11898
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G)>::cmp",
-          "start": 11887
+          "start": 12096
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G, H)>::cmp",
-          "start": 12099
+          "start": 12308
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G, H, I)>::cmp",
-          "start": 12325
+          "start": 12534
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J)>::cmp",
-          "start": 12565
+          "start": 12774
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J, K)>::cmp",
-          "start": 12820
+          "start": 13029
         },
         {
           "name": "<impl Ord for (A, B, C, D, E, F, G, H, I, J, K, L)>::cmp",
-          "start": 13089
+          "start": 13298
         },
         {
           "name": "max",
-          "start": 13451
+          "start": 13660
         },
         {
           "name": "min",
-          "start": 13828
+          "start": 14037
         },
         {
           "name": "cmp_tests::sanity_check_min",
-          "start": 13982
+          "start": 14231
         },
         {
           "name": "cmp_tests::sanity_check_max",
-          "start": 14178
+          "start": 14427
         },
         {
           "name": "cmp_tests::correctly_handles_unequal_length_vectors",
-          "start": 14400
+          "start": 14649
         },
         {
           "name": "cmp_tests::lexicographic_ordering_for_vectors",
-          "start": 14600
+          "start": 14849
+        },
+        {
+          "name": "cmp_tests::eq_unit",
+          "start": 15181
+        },
+        {
+          "name": "cmp_tests::eq_bool",
+          "start": 15246
+        },
+        {
+          "name": "cmp_tests::eq_integers",
+          "start": 15422
+        },
+        {
+          "name": "cmp_tests::eq_tuples",
+          "start": 16163
+        },
+        {
+          "name": "cmp_tests::cmp_unit",
+          "start": 17041
+        },
+        {
+          "name": "cmp_tests::cmp_bool",
+          "start": 17130
+        },
+        {
+          "name": "cmp_tests::cmp_integers",
+          "start": 17394
+        },
+        {
+          "name": "cmp_tests::cmp_tuples",
+          "start": 18217
+        },
+        {
+          "name": "cmp_tests::cmp_array",
+          "start": 19224
+        },
+        {
+          "name": "cmp_tests::cmp_vectors",
+          "start": 19468
         }
       ],
       "path": "std/cmp.nr",
-      "source": "use crate::meta::ctstring::AsCtString;\nuse crate::meta::derive_via;\n\n/// Compare two values for equality\n#[derive_via(derive_eq)]\n// docs:start:eq-trait\npub trait Eq {\n    fn eq(self, other: Self) -> bool;\n}\n// docs:end:eq-trait\n\n// docs:start:derive_eq\ncomptime fn derive_eq(s: TypeDefinition) -> Quoted {\n    let signature = quote { fn eq(_self: Self, _other: Self) -> bool };\n    let for_each_field = |name| quote { (_self.$name == _other.$name) };\n    let body = |fields| {\n        if s.fields_as_written().len() == 0 {\n            quote { true }\n        } else {\n            fields\n        }\n    };\n    crate::meta::make_trait_impl(\n        s,\n        quote { $crate::cmp::Eq },\n        signature,\n        for_each_field,\n        quote { & },\n        body,\n    )\n}\n// docs:end:derive_eq\n\nimpl Eq for Field {\n    fn eq(self, other: Field) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for u128 {\n    fn eq(self, other: u128) -> bool {\n        self == other\n    }\n}\nimpl Eq for u64 {\n    fn eq(self, other: u64) -> bool {\n        self == other\n    }\n}\nimpl Eq for u32 {\n    fn eq(self, other: u32) -> bool {\n        self == other\n    }\n}\nimpl Eq for u16 {\n    fn eq(self, other: u16) -> bool {\n        self == other\n    }\n}\nimpl Eq for u8 {\n    fn eq(self, other: u8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i8 {\n    fn eq(self, other: i8) -> bool {\n        self == other\n    }\n}\nimpl Eq for i16 {\n    fn eq(self, other: i16) -> bool {\n        self == other\n    }\n}\nimpl Eq for i32 {\n    fn eq(self, other: i32) -> bool {\n        self == other\n    }\n}\nimpl Eq for i64 {\n    fn eq(self, other: i64) -> bool {\n        self == other\n    }\n}\n\nimpl Eq for () {\n    fn eq(_self: Self, _other: ()) -> bool {\n        true\n    }\n}\nimpl Eq for bool {\n    fn eq(self, other: bool) -> bool {\n        self == other\n    }\n}\n\nimpl<T, let N: u32> Eq for [T; N]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T; N]) -> bool {\n        let mut result = true;\n        for i in 0..self.len() {\n            result &= self[i].eq(other[i]);\n        }\n        result\n    }\n}\n\nimpl<T> Eq for [T]\nwhere\n    T: Eq,\n{\n    fn eq(self, other: [T]) -> bool {\n        let mut result = self.len() == other.len();\n        if result {\n            for i in 0..self.len() {\n                result &= self[i].eq(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<let N: u32> Eq for str<N> {\n    fn eq(self, other: str<N>) -> bool {\n        let self_bytes = self.as_bytes();\n        let other_bytes = other.as_bytes();\n        self_bytes == other_bytes\n    }\n}\n\ncomptime fn make_tuple_eq_body(n: u32) -> Quoted {\n    let mut body = f\"self.0.eq(other.0)\".as_ctstring();\n    for i in 1u32..n {\n        body = body.append_fmtstr(f\" & self.{i}.eq(other.{i})\");\n    }\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Eq, B: Eq> Eq for (A, B) {\n    fn eq(self, other: (A, B)) -> bool {\n        make_tuple_eq_body!(2u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq> Eq for (A, B, C) {\n    fn eq(self, other: (A, B, C)) -> bool {\n        make_tuple_eq_body!(3u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq> Eq for (A, B, C, D) {\n    fn eq(self, other: (A, B, C, D)) -> bool {\n        make_tuple_eq_body!(4u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq> Eq for (A, B, C, D, E) {\n    fn eq(self, other: (A, B, C, D, E)) -> bool {\n        make_tuple_eq_body!(5u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq> Eq for (A, B, C, D, E, F) {\n    fn eq(self, other: (A, B, C, D, E, F)) -> bool {\n        make_tuple_eq_body!(6u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq> Eq for (A, B, C, D, E, F, G) {\n    fn eq(self, other: (A, B, C, D, E, F, G)) -> bool {\n        make_tuple_eq_body!(7u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq> Eq for (A, B, C, D, E, F, G, H) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H)) -> bool {\n        make_tuple_eq_body!(8u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq> Eq for (A, B, C, D, E, F, G, H, I) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I)) -> bool {\n        make_tuple_eq_body!(9u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq> Eq for (A, B, C, D, E, F, G, H, I, J) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J)) -> bool {\n        make_tuple_eq_body!(10u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> bool {\n        make_tuple_eq_body!(11u32)\n    }\n}\n\nimpl<A: Eq, B: Eq, C: Eq, D: Eq, E: Eq, F: Eq, G: Eq, H: Eq, I: Eq, J: Eq, K: Eq, L: Eq> Eq for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn eq(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> bool {\n        make_tuple_eq_body!(12u32)\n    }\n}\n\nimpl Eq for Ordering {\n    fn eq(self, other: Ordering) -> bool {\n        self.result == other.result\n    }\n}\n\n// Noir doesn't have enums yet so we emulate (Lt | Eq | Gt) with a struct\n// that has 3 public functions for constructing the struct.\n/// A value with three states: `Ordering::less()`, `Ordering::equal()` or `Ordering::greater()`.\n/// Most often used to encode the result of a comparison operation.\npub struct Ordering {\n    result: Field,\n}\n\nimpl Ordering {\n    // Implementation note: 0, 1, and 2 for Lt, Eq, and Gt are built\n    // into the compiler, do not change these without also updating\n    // the compiler itself!\n    pub fn less() -> Ordering {\n        Ordering { result: 0 }\n    }\n\n    pub fn equal() -> Ordering {\n        Ordering { result: 1 }\n    }\n\n    pub fn greater() -> Ordering {\n        Ordering { result: 2 }\n    }\n}\n\n/// Compare one object to another, returning whether it is less-than, equal-to,\n/// or greater-than the other object.\n#[derive_via(derive_ord)]\n// docs:start:ord-trait\npub trait Ord {\n    fn cmp(self, other: Self) -> Ordering;\n}\n// docs:end:ord-trait\n\n// docs:start:derive_ord\ncomptime fn derive_ord(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::cmp::Ord };\n    let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };\n    let for_each_field = |name| quote {\n        if result == $crate::cmp::Ordering::equal() {\n            result = _self.$name.cmp(_other.$name);\n        }\n    };\n    let body = |fields| quote {\n        let mut result = $crate::cmp::Ordering::equal();\n        $fields\n        result\n    };\n    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)\n}\n// docs:end:derive_ord\n\n// Note: Field deliberately does not implement Ord\n\nimpl Ord for u128 {\n    fn cmp(self, other: u128) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\nimpl Ord for u64 {\n    fn cmp(self, other: u64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u32 {\n    fn cmp(self, other: u32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u16 {\n    fn cmp(self, other: u16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for u8 {\n    fn cmp(self, other: u8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i8 {\n    fn cmp(self, other: i8) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i16 {\n    fn cmp(self, other: i16) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i32 {\n    fn cmp(self, other: i32) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for i64 {\n    fn cmp(self, other: i64) -> Ordering {\n        if self < other {\n            Ordering::less()\n        } else if self > other {\n            Ordering::greater()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl Ord for () {\n    fn cmp(_self: Self, _other: ()) -> Ordering {\n        Ordering::equal()\n    }\n}\n\nimpl Ord for bool {\n    fn cmp(self, other: bool) -> Ordering {\n        if self {\n            if other {\n                Ordering::equal()\n            } else {\n                Ordering::greater()\n            }\n        } else if other {\n            Ordering::less()\n        } else {\n            Ordering::equal()\n        }\n    }\n}\n\nimpl<T, let N: u32> Ord for [T; N]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T; N]) -> Ordering {\n        let mut result = Ordering::equal();\n        for i in 0..self.len() {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n        result\n    }\n}\n\nimpl<T> Ord for [T]\nwhere\n    T: Ord,\n{\n    // The first non-equal element of both arrays determines\n    // the ordering for the whole array.\n    fn cmp(self, other: [T]) -> Ordering {\n        let self_len = self.len();\n        let other_len = other.len();\n        let min_len = if self_len < other_len {\n            self_len\n        } else {\n            other_len\n        };\n\n        let mut result = Ordering::equal();\n        for i in 0..min_len {\n            if result == Ordering::equal() {\n                result = self[i].cmp(other[i]);\n            }\n        }\n\n        if result != Ordering::equal() {\n            result\n        } else {\n            self_len.cmp(other_len)\n        }\n    }\n}\n\ncomptime fn make_tuple_ord_body(n: u32) -> Quoted {\n    let last = n - 1u32;\n    let mut body = if last == 1 {\n        f\"let result = self.0.cmp(other.0);\".as_ctstring()\n    } else {\n        f\"let mut result = self.0.cmp(other.0);\".as_ctstring()\n    };\n    for i in 1u32..last {\n        body = body.append_fmtstr(\n            f\" if result == Ordering::equal() {{ result = self.{i}.cmp(other.{i}); }}\",\n        );\n    }\n    body = body.append_fmtstr(\n        f\" if result != Ordering::equal() {{ result }} else {{ self.{last}.cmp(other.{last}) }}\",\n    );\n    f\"{body}\".quoted_contents()\n}\n\nimpl<A: Ord, B: Ord> Ord for (A, B) {\n    fn cmp(self, other: (A, B)) -> Ordering {\n        make_tuple_ord_body!(2u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord> Ord for (A, B, C) {\n    fn cmp(self, other: (A, B, C)) -> Ordering {\n        make_tuple_ord_body!(3u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord> Ord for (A, B, C, D) {\n    fn cmp(self, other: (A, B, C, D)) -> Ordering {\n        make_tuple_ord_body!(4u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord> Ord for (A, B, C, D, E) {\n    fn cmp(self, other: (A, B, C, D, E)) -> Ordering {\n        make_tuple_ord_body!(5u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord> Ord for (A, B, C, D, E, F) {\n    fn cmp(self, other: (A, B, C, D, E, F)) -> Ordering {\n        make_tuple_ord_body!(6u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord> Ord for (A, B, C, D, E, F, G) {\n    fn cmp(self, other: (A, B, C, D, E, F, G)) -> Ordering {\n        make_tuple_ord_body!(7u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord> Ord for (A, B, C, D, E, F, G, H) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H)) -> Ordering {\n        make_tuple_ord_body!(8u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord> Ord for (A, B, C, D, E, F, G, H, I) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I)) -> Ordering {\n        make_tuple_ord_body!(9u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord> Ord for (A, B, C, D, E, F, G, H, I, J) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J)) -> Ordering {\n        make_tuple_ord_body!(10u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K)) -> Ordering {\n        make_tuple_ord_body!(11u32)\n    }\n}\n\nimpl<A: Ord, B: Ord, C: Ord, D: Ord, E: Ord, F: Ord, G: Ord, H: Ord, I: Ord, J: Ord, K: Ord, L: Ord> Ord for (A, B, C, D, E, F, G, H, I, J, K, L) {\n    fn cmp(self, other: (A, B, C, D, E, F, G, H, I, J, K, L)) -> Ordering {\n        make_tuple_ord_body!(12u32)\n    }\n}\n\n/// Compares and returns the maximum of two values.\n///\n/// Returns the second argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::max(1, 2), 2);\n/// assert_eq(cmp::max(2, 2), 2);\n/// ```\npub fn max<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v1\n    } else {\n        v2\n    }\n}\n\n/// Compares and returns the minimum of two values.\n///\n/// Returns the first argument if the comparison determines them to be equal.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq(cmp::min(1, 2), 1);\n/// assert_eq(cmp::min(2, 2), 2);\n/// ```\npub fn min<T>(v1: T, v2: T) -> T\nwhere\n    T: Ord,\n{\n    if v1 > v2 {\n        v2\n    } else {\n        v1\n    }\n}\n\nmod cmp_tests {\n    use super::{Eq, max, min, Ord};\n\n    #[test]\n    fn sanity_check_min() {\n        assert_eq(min(0_u64, 1), 0);\n        assert_eq(min(0_u64, 0), 0);\n        assert_eq(min(1_u64, 1), 1);\n        assert_eq(min(255_u8, 0), 0);\n    }\n\n    #[test]\n    fn sanity_check_max() {\n        assert_eq(max(0_u64, 1), 1);\n        assert_eq(max(0_u64, 0), 0);\n        assert_eq(max(1_u64, 1), 1);\n        assert_eq(max(255_u8, 0), 255);\n    }\n\n    #[test]\n    fn correctly_handles_unequal_length_vectors() {\n        let vector_1 = [0, 1, 2, 3].as_vector();\n        let vector_2 = [0, 1, 2].as_vector();\n        assert(!vector_1.eq(vector_2));\n    }\n\n    #[test]\n    fn lexicographic_ordering_for_vectors() {\n        assert(\n            [2_u32].as_vector().cmp([1_u32, 1_u32, 1_u32].as_vector())\n                == super::Ordering::greater(),\n        );\n        assert(\n            [1_u32, 2_u32].as_vector().cmp([1_u32, 2_u32, 3_u32].as_vector())\n                == super::Ordering::less(),\n        );\n    }\n}\n"
+      "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": {
+      "function_locations": [
+        {
+          "name": "ContractInstanceRegistry::ContractInstancePublished::serialize_non_standard",
+          "start": 1995
+        },
+        {
+          "name": "ContractInstanceRegistry::publish_for_public_execution",
+          "start": 5010
+        },
+        {
+          "name": "ContractInstanceRegistry::update",
+          "start": 9119
+        },
+        {
+          "name": "ContractInstanceRegistry::set_update_delay",
+          "start": 11330
+        },
+        {
+          "name": "ContractInstanceRegistry::get_update_delay",
+          "start": 12633
+        },
+        {
+          "name": "ContractInstanceRegistry::public_dispatch",
+          "start": 13785
+        },
+        {
+          "name": "ContractInstanceRegistry::Storage<Context>::init",
+          "start": 14918
+        }
+      ],
+      "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/contract_instance_registry_contract/src/main.nr",
+      "source": "/// Protocol contract responsible for deploying contract instances and managing contract upgrades.\n///\n/// In Aztec, contracts are split into *classes* (code, registered via ContractClassRegistry) and *instances*\n/// (deployments of a class at a unique address). This contract handles contract instance publishing and contract\n/// updates (updating instance to a new class).\npub contract ContractInstanceRegistry {\n    use aztec::{\n        context::{PrivateContext, PublicContext},\n        hash::hash_args,\n        nullifier::utils::compute_nullifier_existence_request,\n        oracle::{avm, logging::debug_log_format, version::assert_compatible_oracle_version},\n        protocol::{\n            abis::function_selector::FunctionSelector,\n            address::{AztecAddress, PartialAddress},\n            constants::{\n                CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS, CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE, DEFAULT_UPDATE_DELAY, MINIMUM_UPDATE_DELAY,\n            },\n            contract_class_id::ContractClassId,\n            public_keys::PublicKeys,\n            traits::{Deserialize, Serialize, ToField},\n            utils::reader::Reader,\n        },\n        state_vars::{DelayedPublicMutable, Map, StateVariable},\n    };\n\n    #[abi(events)]\n    struct ContractInstancePublished {\n        CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        version: u8,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        immutables_hash: Field,\n        public_keys: PublicKeys,\n        deployer: AztecAddress,\n    }\n\n    // Custom serialization is required because:\n    // - npk_m, ovpk_m, tpk_m, mspk_m, fbpk_m are exposed only as hashes so we serialize the hashes\n    //   directly.\n    // - For ivpk_m we drop the `is_infinite` flag (we assume non-infinity).\n    impl ContractInstancePublished {\n        fn serialize_non_standard(self) -> [Field; 15] {\n            [\n                self.CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n                self.address.to_field(),\n                self.version.to_field(),\n                self.salt,\n                self.contract_class_id.to_field(),\n                self.initialization_hash,\n                self.immutables_hash,\n                self.public_keys.npk_m_hash,\n                self.public_keys.ivpk_m.inner.x,\n                self.public_keys.ivpk_m.inner.y,\n                self.public_keys.ovpk_m_hash,\n                self.public_keys.tpk_m_hash,\n                self.public_keys.mspk_m_hash,\n                self.public_keys.fbpk_m_hash,\n                self.deployer.to_field(),\n            ]\n        }\n    }\n\n    #[abi(events)]\n    #[derive(Serialize)]\n    struct ContractInstanceUpdated {\n        CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE: Field,\n        address: AztecAddress,\n        prev_contract_class_id: ContractClassId,\n        new_contract_class_id: ContractClassId,\n        timestamp_of_change: u64,\n    }\n\n    struct Storage<Context> {\n        /// Map from contract instance address to a `DelayedPublicMutable` holding the updated contract class ID.\n        updated_class_ids: Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context>,\n    }\n\n    /// Publishes a new contract instance.\n    ///\n    /// The caller provides deployment parameters (salt, class_id, init_hash, immutables_hash, public_keys,\n    /// universal_deploy).\n    /// The `universal_deploy` flag controls whether the deployer address is bound into the contract address:\n    /// when true, deployer is zero (anyone can deploy the same instance); when false, deployer is the caller.\n    ///\n    /// This function:\n    /// 1. Verifies the contract class is registered in ContractClassRegistry (nullifier existence check).\n    /// 2. Validates `ivpk_m` is on the Grumpkin curve and not the point at infinity (preventing AVM DoS via an invalid\n    /// point). `npk_m`, `ovpk_m`, `tpk_m`, `mspk_m`, and `fbpk_m` are exposed only as hashes and are not validated\n    /// in-circuit.\n    /// 3. Computes the deterministic contract address from the deployment parameters.\n    /// 4. Emits the address as a nullifier (proving publication preventing duplicate deployment)\n    ///    --> this address nullifier is then checked to exist by the AVM upon public function execution (if it doesn't\n    ///        exist AVM reverts)\n    /// 5. Broadcasts a `ContractInstancePublished` event so nodes can reconstruct the instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_private]\n    fn publish_for_public_execution(\n        inputs: aztec::context::inputs::PrivateContextInputs,\n        salt: Field,\n        contract_class_id: ContractClassId,\n        initialization_hash: Field,\n        immutables_hash: Field,\n        public_keys: PublicKeys,\n        universal_deploy: bool,\n    ) -> return_data aztec::protocol::abis::private_circuit_public_inputs::PrivateCircuitPublicInputs {\n        // MACRO CODE START\n        // Note: The macros initially inserted a phase check here, but since there is no phase change in this function\n        // body, I have removed that check.\n        assert_compatible_oracle_version();\n\n        // 4 prefix fields (salt, class_id, init_hash, immutables_hash) + 7 public-key fields\n        // + 1 universal_deploy flag = 12.\n        let serialized_params: [Field; 12] = [salt, contract_class_id.to_field(), initialization_hash, immutables_hash]\n            .concat(public_keys.serialize())\n            .concat([universal_deploy.to_field()]);\n\n        let args_hash: Field = hash_args(serialized_params);\n        let mut context: PrivateContext = PrivateContext::new(inputs, args_hash);\n        // MACRO CODE END\n\n        // Verify the contract class is registered by checking for its nullifier at the ContractClassRegistry address.\n        let nullifier_existence_request = compute_nullifier_existence_request(\n            contract_class_id.to_field(),\n            CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS,\n        );\n        context.assert_nullifier_exists(nullifier_existence_request);\n\n        // For universal deployments, deployer is zero so the resulting address is the same regardless of who initiates\n        // deployment.\n        let deployer = if universal_deploy {\n            AztecAddress::zero()\n        } else {\n            context.maybe_msg_sender().unwrap()\n        };\n\n        let partial_address = PartialAddress::compute(\n            contract_class_id,\n            salt,\n            initialization_hash,\n            deployer,\n            immutables_hash,\n        );\n\n        // Validate `ivpk_m` is on the Grumpkin curve and is not the point at infinity (preventing AVM\n        // DoS attacks). The other five master keys are exposed as hashes and have no\n        // curve-point to validate here.\n        public_keys.validate_on_curve();\n        public_keys.validate_non_infinity();\n\n        let address = AztecAddress::compute(public_keys, partial_address);\n\n        // Emit address as nullifier: prevents duplicate deployment and proves publication.\n        // We use no domain separators because these are the only nullifiers this contract uses.\n        context.push_nullifier(address.to_field());\n\n        // Broadcast deployment event. Version 2 carries hashes for npk/ovpk/tpk/mspk/fbpk and the\n        // affine coordinates of ivpk only; see `serialize_non_standard`.\n        let event = ContractInstancePublished {\n            CONTRACT_INSTANCE_PUBLISHED_MAGIC_VALUE,\n            contract_class_id,\n            address,\n            public_keys,\n            initialization_hash,\n            immutables_hash,\n            salt,\n            deployer,\n            version: 2,\n        };\n        let payload = event.serialize_non_standard();\n        debug_log_format(\"ContractInstancePublished: {}\", payload);\n        // We pad the payload with zeros to match the length required by emit_private_log (PRIVATE_LOG_SIZE_IN_FIELDS).\n        // Since the log is not encrypted, padding with zero rather than a random value is acceptable (we don't care\n        // about privacy here).\n        let padded_log = payload.concat([0]);\n        let length = payload.len();\n        context.emit_private_log(padded_log, length);\n\n        // MACRO CODE START\n        context.finish()\n        // MACRO CODE END\n    }\n\n    /// Schedules an upgrade of the calling contract instance to a new contract class.\n    ///\n    /// The change is time-delayed via `DelayedPublicMutable` and only takes effect after the configured\n    /// delay has elapsed. Only the contract instance itself can call this function (msg.sender == address).\n    ///\n    /// This function:\n    /// 1. Verifies msg.sender is a deployed contract (its address nullifier exists).\n    /// 2. Verifies the new class is registered in ContractClassRegistry.\n    /// 3. Schedules the class ID change and emits a `ContractInstanceUpdated` event.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn update(new_contract_class_id: ContractClassId) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let address = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(address.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the new contract class'\n        // information through registration, which is safe - we just need this information to be _eventually_\n        // available.\n        assert(\n            context.nullifier_exists_unsafe(new_contract_class_id.to_field(), CONTRACT_CLASS_REGISTRY_CONTRACT_ADDRESS),\n            \"New contract class is not registered\",\n        );\n\n        let scheduled_value_update =\n            storage.updated_class_ids.at(address).schedule_and_get_value_change(new_contract_class_id);\n        let (prev_contract_class_id, timestamp_of_change) = scheduled_value_update.get_previous();\n\n        let event = ContractInstanceUpdated {\n            CONTRACT_INSTANCE_UPDATED_MAGIC_VALUE,\n            address,\n            prev_contract_class_id,\n            new_contract_class_id,\n            timestamp_of_change,\n        };\n        context.emit_public_log(event);\n    }\n\n    /// Schedules a change to the upgrade delay for the calling contract instance. The delay change is\n    /// itself delayed (preventing atomically reducing delay + scheduling an instant upgrade). The new\n    /// delay must be at least `MINIMUM_UPDATE_DELAY`.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    unconstrained fn set_update_delay(new_update_delay: u64) {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        // MACRO CODE END\n\n        let msg_sender = context.maybe_msg_sender().unwrap();\n\n        // Safety: we're using the nullifier's existence as a guarantee of the availability of the contract's\n        // information through publishing, which is safe - we just need this information to be _eventually_ available.\n        assert(\n            context.nullifier_exists_unsafe(msg_sender.to_field(), context.this_address()),\n            \"msg.sender is not deployed\",\n        );\n\n        assert(new_update_delay >= MINIMUM_UPDATE_DELAY, \"New update delay is too low\");\n\n        storage.updated_class_ids.at(msg_sender).schedule_delay_change(new_update_delay);\n    }\n\n    /// Returns the current update delay for the calling contract instance.\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_view]\n    unconstrained fn get_update_delay() -> pub u64 {\n        // MACRO CODE START\n        let context: PublicContext = PublicContext::new(\n            || -> Field {\n                let serialized_args: [Field; 0] = avm::calldata_copy(1, 0);\n                hash_args(serialized_args)\n            },\n        );\n        let storage: Storage<PublicContext> = Storage::init(context);\n        assert(context.is_static_call(), \"Function get_update_delay can only be called statically\");\n        // MACRO CODE END\n\n        storage.updated_class_ids.at(avm::sender()).get_current_delay()\n    }\n\n    // THE REST OF THE CODE IN THIS CONTRACT WAS ORIGINALLY INJECTED BY THE #[aztec] MACRO.\n\n    global UPDATE_SELECTOR: Field = comptime { FunctionSelector::from_signature(\"update((Field))\").to_field() };\n    global SET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"set_update_delay(u64)\").to_field() };\n    global GET_UPDATE_DELAY_SELECTOR: Field =\n        comptime { FunctionSelector::from_signature(\"get_update_delay()\").to_field() };\n\n    #[aztec::macros::internals_functions_generation::abi_attributes::abi_public]\n    pub unconstrained fn public_dispatch(selector: Field) {\n        if selector == UPDATE_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <ContractClassId as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: ContractClassId = <ContractClassId as Deserialize>::stream_deserialize(&mut reader);\n            update(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == SET_UPDATE_DELAY_SELECTOR {\n            let input_calldata: [Field; 1] = avm::calldata_copy(1, <u64 as Serialize>::N);\n            let mut reader: Reader<1> = Reader::new(input_calldata);\n            let arg0: u64 = <u64 as Deserialize>::stream_deserialize(&mut reader);\n            set_update_delay(arg0);\n            avm::avm_return([].as_vector());\n        };\n        if selector == GET_UPDATE_DELAY_SELECTOR {\n            let return_value: [Field; 1] = <u64 as Serialize>::serialize(get_update_delay());\n            avm::avm_return(return_value.as_vector());\n        };\n        panic(f\"Unknown selector {selector}\")\n    }\n\n    impl<Context> Storage<Context> {\n        fn init(context: Context) -> Self {\n            Self {\n                updated_class_ids: <Map<AztecAddress, DelayedPublicMutable<ContractClassId, DEFAULT_UPDATE_DELAY, Context>, Context> as StateVariable<1, Context>>::new(\n                    context,\n                    1,\n                ),\n            }\n        }\n    }\n\n    pub struct publish_for_public_execution_parameters {\n        pub _salt: Field,\n        pub _contract_class_id: ContractClassId,\n        pub _initialization_hash: Field,\n        pub _immutables_hash: Field,\n        pub _public_keys: PublicKeys,\n        pub _universal_deploy: bool,\n    }\n\n    pub struct update_parameters {\n        pub _new_contract_class_id: ContractClassId,\n    }\n\n    pub struct set_update_delay_parameters {\n        pub _new_update_delay: u64,\n    }\n\n    pub struct get_update_delay_parameters {}\n\n    #[abi(functions)]\n    pub struct publish_for_public_execution_abi {\n        parameters: publish_for_public_execution_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct update_abi {\n        parameters: update_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct set_update_delay_abi {\n        parameters: set_update_delay_parameters,\n    }\n\n    #[abi(functions)]\n    pub struct get_update_delay_abi {\n        parameters: get_update_delay_parameters,\n        return_type: u64,\n    }\n}\n"
     },
     "56": {
       "function_locations": [
@@ -1972,59 +2344,59 @@
         },
         {
           "name": "PrivateContext::end_setup",
-          "start": 8177
+          "start": 8235
         },
         {
           "name": "PrivateContext::in_revertible_phase",
-          "start": 8426
+          "start": 8484
         },
         {
           "name": "PrivateContext::set_expiration_timestamp",
-          "start": 9311
+          "start": 9369
         },
         {
           "name": "PrivateContext::push_nullifier",
-          "start": 9553
+          "start": 9611
         },
         {
           "name": "PrivateContext::assert_nullifier_exists",
-          "start": 9913
+          "start": 9971
         },
         {
           "name": "PrivateContext::consume_l1_to_l2_message",
-          "start": 10553
+          "start": 10611
         },
         {
           "name": "PrivateContext::emit_private_log",
-          "start": 11145
+          "start": 11203
         },
         {
           "name": "PrivateContext::emit_contract_class_log",
-          "start": 11507
+          "start": 11565
         },
         {
           "name": "PrivateContext::static_call_private_function",
-          "start": 13005
+          "start": 13063
         },
         {
           "name": "PrivateContext::call_private_function_with_args_hash",
-          "start": 13493
+          "start": 13551
         },
         {
           "name": "PrivateContext::call_public_function_with_calldata_hash",
-          "start": 14997
+          "start": 15055
         },
         {
           "name": "PrivateContext::next_counter",
-          "start": 15578
+          "start": 15636
         },
         {
           "name": "<impl Empty for PrivateContext>::empty",
-          "start": 15747
+          "start": 15805
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/private_context.nr",
-      "source": "use crate::{\n    context::{inputs::PrivateContextInputs, NullifierExistenceRequest, ReturnsHash},\n    hash::hash_args,\n    messaging::process_l1_to_l2_message,\n    oracle::{\n        call_private_function::call_private_function_internal,\n        public_call::validate_public_calldata,\n        tx_phase::{in_revertible_phase, notify_revertible_phase_start},\n        execution_cache,\n        logs::notify_created_contract_class_log,\n        nullifiers::notify_created_nullifier,\n    },\n};\nuse crate::protocol::{\n    abis::{\n        block_header::BlockHeader,\n        call_context::CallContext,\n        function_selector::FunctionSelector,\n        gas_settings::GasSettings,\n        log_hash::LogHash,\n        nullifier::Nullifier,\n        private_call_request::PrivateCallRequest,\n        private_circuit_public_inputs::PrivateCircuitPublicInputs,\n        private_log::{PrivateLog, PrivateLogData},\n        public_call_request::PublicCallRequest,\n    },\n    address::{AztecAddress, EthAddress},\n    constants::{\n        CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, MAX_CONTRACT_CLASS_LOGS_PER_CALL,\n        MAX_ENQUEUED_CALLS_PER_CALL, MAX_TX_LIFETIME, MAX_L2_TO_L1_MSGS_PER_CALL,\n        MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL,\n        MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL,\n        NULL_MSG_SENDER_CONTRACT_ADDRESS, PRIVATE_LOG_SIZE_IN_FIELDS,\n    },\n    hash::poseidon2_hash,\n    messaging::l2_to_l1_message::L2ToL1Message,\n    side_effect::{Counted, scoped::Scoped},\n    traits::Empty,\n    utils::arrays::{ClaimedLengthArray, trimmed_array_length_hint},\n};\n\n/// Minimal PrivateContext for protocol contracts going to audit.\n/// Contains only the methods actually used by: fee_juice, auth_registry, contract_class_registry, contract_instance_registry\n#[derive(Eq)]\npub struct PrivateContext {\n    pub inputs: PrivateContextInputs,\n    pub side_effect_counter: u32,\n\n    pub min_revertible_side_effect_counter: u32,\n    pub is_fee_payer: bool,\n\n    pub args_hash: Field,\n    pub return_hash: Field,\n\n    pub expiration_timestamp: u64,\n\n    pub nullifier_read_requests: BoundedVec<Scoped<Counted<Field>>, MAX_NULLIFIER_READ_REQUESTS_PER_CALL>,\n\n    pub nullifiers: BoundedVec<Counted<Nullifier>, MAX_NULLIFIERS_PER_CALL>,\n\n    pub private_call_requests: BoundedVec<PrivateCallRequest, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,\n    pub public_call_requests: BoundedVec<Counted<PublicCallRequest>, MAX_ENQUEUED_CALLS_PER_CALL>,\n    pub public_teardown_call_request: PublicCallRequest,\n    pub l2_to_l1_msgs: BoundedVec<Counted<L2ToL1Message>, MAX_L2_TO_L1_MSGS_PER_CALL>,\n\n    // Header of a block whose state is used during private execution (not the block the transaction is included in).\n    pub anchor_block_header: BlockHeader,\n\n    pub private_logs: BoundedVec<Counted<PrivateLogData>, MAX_PRIVATE_LOGS_PER_CALL>,\n    pub contract_class_logs_hashes: BoundedVec<Counted<LogHash>, MAX_CONTRACT_CLASS_LOGS_PER_CALL>,\n\n    pub expected_non_revertible_side_effect_counter: u32,\n    pub expected_revertible_side_effect_counter: u32,\n}\n\nimpl PrivateContext {\n    pub fn new(inputs: PrivateContextInputs, args_hash: Field) -> PrivateContext {\n        PrivateContext {\n            inputs,\n            side_effect_counter: inputs.start_side_effect_counter + 1,\n            min_revertible_side_effect_counter: 0,\n            is_fee_payer: false,\n            args_hash,\n            return_hash: 0,\n            expiration_timestamp: inputs.anchor_block_header.global_variables.timestamp\n            + MAX_TX_LIFETIME,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            anchor_block_header: inputs.anchor_block_header,\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n\n    /// Returns the contract address that initiated this function call (similar to msg.sender in Solidity).\n    pub fn maybe_msg_sender(self) -> Option<AztecAddress> {\n        let maybe_msg_sender = self.inputs.call_context.msg_sender;\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the contract address of the current function being executed.\n    pub fn this_address(self) -> AztecAddress {\n        self.inputs.call_context.contract_address\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(self) -> Field {\n        self.inputs.tx_context.chain_id\n    }\n\n    /// Returns the protocol version.\n    pub fn version(self) -> Field {\n        self.inputs.tx_context.version\n    }\n\n    /// Returns the gas settings for the current transaction.\n    pub fn gas_settings(self) -> GasSettings {\n        self.inputs.tx_context.gas_settings\n    }\n\n    /// Returns the function selector of the currently executing function.\n    pub fn selector(self) -> FunctionSelector {\n        self.inputs.call_context.function_selector\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(self) -> Field {\n        self.args_hash\n    }\n\n    /// Returns the anchor block header.\n    pub fn get_anchor_block_header(self) -> BlockHeader {\n        self.anchor_block_header\n    }\n\n    /// Sets the hash of the return values for this private function.\n    pub fn set_return_hash<let N: u32>(&mut self, serialized_return_values: [Field; N]) {\n        let return_hash = hash_args(serialized_return_values);\n        self.return_hash = return_hash;\n        execution_cache::store(serialized_return_values, return_hash);\n    }\n\n    /// Builds the PrivateCircuitPublicInputs for this private function.\n    pub fn finish(self) -> PrivateCircuitPublicInputs {\n        PrivateCircuitPublicInputs {\n            call_context: self.inputs.call_context,\n            args_hash: self.args_hash,\n            returns_hash: self.return_hash,\n            min_revertible_side_effect_counter: self.min_revertible_side_effect_counter,\n            is_fee_payer: self.is_fee_payer,\n            expiration_timestamp: self.expiration_timestamp,\n            note_hash_read_requests: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifier_read_requests: ClaimedLengthArray::from_bounded_vec(\n                self.nullifier_read_requests,\n            ),\n            key_validation_requests_and_separators: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            note_hashes: ClaimedLengthArray::empty(), // Not used by protocol contracts\n            nullifiers: ClaimedLengthArray::from_bounded_vec(self.nullifiers),\n            private_call_requests: ClaimedLengthArray::from_bounded_vec(self.private_call_requests),\n            public_call_requests: ClaimedLengthArray::from_bounded_vec(self.public_call_requests),\n            public_teardown_call_request: self.public_teardown_call_request,\n            l2_to_l1_msgs: ClaimedLengthArray::from_bounded_vec(self.l2_to_l1_msgs),\n            start_side_effect_counter: self.inputs.start_side_effect_counter,\n            end_side_effect_counter: self.side_effect_counter,\n            private_logs: ClaimedLengthArray::from_bounded_vec(self.private_logs),\n            contract_class_logs_hashes: ClaimedLengthArray::from_bounded_vec(\n                self.contract_class_logs_hashes,\n            ),\n            anchor_block_header: self.anchor_block_header,\n            tx_context: self.inputs.tx_context,\n            expected_non_revertible_side_effect_counter: self\n                .expected_non_revertible_side_effect_counter,\n            expected_revertible_side_effect_counter: self.expected_revertible_side_effect_counter,\n        }\n    }\n\n    /// Declares the end of the \"setup phase\" of this tx. Used by fee_juice.\n    pub fn end_setup(&mut self) {\n        self.side_effect_counter += 1;\n        self.min_revertible_side_effect_counter = self.next_counter();\n        notify_revertible_phase_start(self.min_revertible_side_effect_counter);\n    }\n\n    pub fn in_revertible_phase(&mut self) -> bool {\n        let current_counter = self.side_effect_counter;\n\n        // Safety: Kernel will validate that the claim is correct by validating the expected counters.\n        let is_revertible =\n            unsafe { in_revertible_phase(current_counter) };\n\n        if is_revertible {\n            if (self.expected_revertible_side_effect_counter == 0)\n                | (current_counter < self.expected_revertible_side_effect_counter) {\n                self.expected_revertible_side_effect_counter = current_counter;\n            }\n        } else if current_counter > self.expected_non_revertible_side_effect_counter {\n            self.expected_non_revertible_side_effect_counter = current_counter;\n        }\n\n        is_revertible\n    }\n\n    /// Sets a deadline for when this transaction must be included in a block.\n    pub fn set_expiration_timestamp(&mut self, expiration_timestamp: u64) {\n        self.expiration_timestamp = std::cmp::min(self.expiration_timestamp, expiration_timestamp);\n    }\n\n    /// Pushes a new nullifier. Used by class_registry and instance_registry.\n    pub fn push_nullifier(&mut self, nullifier: Field) {\n        notify_created_nullifier(nullifier);\n        self.nullifiers.push(Nullifier { value: nullifier, note_hash: 0 }.count(self.next_counter()));\n    }\n\n    /// Asserts that a nullifier has been emitted. Used by instance_registry.\n    pub fn assert_nullifier_exists(\n        &mut self,\n        nullifier_existence_request: NullifierExistenceRequest,\n    ) {\n        let nullifier = nullifier_existence_request.nullifier();\n        let contract_address =\n            nullifier_existence_request.maybe_contract_address().unwrap_or(AztecAddress::zero());\n\n        let request = Scoped::new(\n            Counted::new(nullifier, self.next_counter()),\n            contract_address,\n        );\n\n        self.nullifier_read_requests.push(request);\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2). Used by fee_juice.\n    pub fn consume_l1_to_l2_message(\n        &mut self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let nullifier = process_l1_to_l2_message(\n            self.anchor_block_header.state.l1_to_l2_message_tree.root,\n            self.this_address(),\n            sender,\n            self.chain_id(),\n            self.version(),\n            content,\n            secret,\n            leaf_index,\n        );\n\n        // Push nullifier (and the \"commitment\" corresponding to this can be \"empty\")\n        self.push_nullifier(nullifier)\n    }\n\n    /// Emits a private log. Used by instance_registry.\n    pub fn emit_private_log(&mut self, log: [Field; PRIVATE_LOG_SIZE_IN_FIELDS], length: u32) {\n        let counter = self.next_counter();\n        let private_log = PrivateLogData { log: PrivateLog::new(log, length), note_hash_counter: 0 }\n            .count(counter);\n        self.private_logs.push(private_log);\n    }\n\n    /// Emits a contract class log. Used by class_registry.\n    pub fn emit_contract_class_log<let N: u32>(&mut self, log: [Field; N]) {\n        let contract_address = self.this_address();\n        let counter = self.next_counter();\n\n        let log_to_emit: [Field; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS] =\n            log.concat([0; CONTRACT_CLASS_LOG_SIZE_IN_FIELDS - N]);\n        // Safety: The below length is constrained in the base rollup, which will make sure that all the fields beyond\n        // length are zero. However, it won't be able to check that we didn't add extra padding (trailing zeroes) or\n        // that we cut trailing zeroes from the end.\n        let length = unsafe { trimmed_array_length_hint(log_to_emit) };\n        // We hash the entire padded log to ensure a user cannot pass a shorter length and so emit incorrect shorter\n        // bytecode.\n        let log_hash = poseidon2_hash(log_to_emit);\n        // Safety: the below only exists to broadcast the raw log, so we can provide it to the base rollup later to be\n        // constrained.\n        unsafe {\n            notify_created_contract_class_log(contract_address, log_to_emit, length, counter);\n        }\n\n        self.contract_class_logs_hashes.push(LogHash { value: log_hash, length: length }.count(\n            counter,\n        ));\n    }\n\n    /// Makes a read-only call to a private function. Used by auth_registry for authwit.\n    pub fn static_call_private_function<let ArgsCount: u32>(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; ArgsCount],\n    ) -> ReturnsHash {\n        let args_hash = hash_args(args);\n        execution_cache::store(args, args_hash);\n        self.call_private_function_with_args_hash(\n            contract_address,\n            function_selector,\n            args_hash,\n            true,\n        )\n    }\n\n    fn call_private_function_with_args_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args_hash: Field,\n        is_static_call: bool,\n    ) -> ReturnsHash {\n        let mut is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n        let start_side_effect_counter = self.side_effect_counter;\n\n        // Safety: The oracle simulates the private call and returns the value of the side effects counter after\n        // execution of the call.\n        let (end_side_effect_counter, returns_hash) = unsafe {\n            call_private_function_internal(\n                contract_address,\n                function_selector,\n                args_hash,\n                start_side_effect_counter,\n                is_static_call,\n            )\n        };\n\n        self.private_call_requests.push(\n            PrivateCallRequest {\n                call_context: CallContext {\n                    msg_sender: self.this_address(),\n                    contract_address,\n                    function_selector,\n                    is_static_call,\n                },\n                args_hash,\n                returns_hash,\n                start_side_effect_counter,\n                end_side_effect_counter,\n            },\n        );\n\n        self.side_effect_counter = end_side_effect_counter + 1;\n        ReturnsHash::new(returns_hash)\n    }\n\n    /// Enqueues a call to a public function with a calldata hash. Used by fee_juice and auth_registry.\n    pub fn call_public_function_with_calldata_hash(\n        &mut self,\n        contract_address: AztecAddress,\n        calldata_hash: Field,\n        is_static_call: bool,\n        hide_msg_sender: bool,\n    ) {\n        let counter = self.next_counter();\n\n        let is_static_call = is_static_call | self.inputs.call_context.is_static_call;\n\n        validate_public_calldata(calldata_hash);\n\n        let msg_sender = if hide_msg_sender {\n            NULL_MSG_SENDER_CONTRACT_ADDRESS\n        } else {\n            self.this_address()\n        };\n\n        let call_request =\n            PublicCallRequest { msg_sender, contract_address, is_static_call, calldata_hash };\n\n        self.public_call_requests.push(Counted::new(call_request, counter));\n    }\n\n    fn next_counter(&mut self) -> u32 {\n        let counter = self.side_effect_counter;\n        self.side_effect_counter += 1;\n        counter\n    }\n}\n\nimpl Empty for PrivateContext {\n    fn empty() -> Self {\n        PrivateContext {\n            inputs: PrivateContextInputs::empty(),\n            side_effect_counter: 0 as u32,\n            min_revertible_side_effect_counter: 0 as u32,\n            is_fee_payer: false,\n            args_hash: 0,\n            return_hash: 0,\n            expiration_timestamp: 0,\n            nullifier_read_requests: BoundedVec::new(),\n            nullifiers: BoundedVec::new(),\n            private_call_requests: BoundedVec::new(),\n            public_call_requests: BoundedVec::new(),\n            public_teardown_call_request: PublicCallRequest::empty(),\n            l2_to_l1_msgs: BoundedVec::new(),\n            anchor_block_header: BlockHeader::empty(),\n            private_logs: BoundedVec::new(),\n            contract_class_logs_hashes: BoundedVec::new(),\n            expected_non_revertible_side_effect_counter: 0,\n            expected_revertible_side_effect_counter: 0,\n        }\n    }\n}\n"
+      "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": {
       "function_locations": [
@@ -2468,29 +2840,29 @@
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
-          "start": 1191
+          "start": 1192
         },
         {
           "name": "assert_compatible_oracle_version_wrapper",
-          "start": 1500
+          "start": 1501
         },
         {
           "name": "assert_compatible_oracle_version_oracle",
-          "start": 1730
+          "start": 1732
         },
         {
           "name": "test::compatible_oracle_version",
-          "start": 1924
+          "start": 1926
         },
         {
           "name": "test::incompatible_oracle_version_major",
-          "start": 2149
+          "start": 2151
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_utl_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 28;\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_utl_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"
+      "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"
     },
-    "84": {
+    "83": {
       "function_locations": [
         {
           "name": "<impl StateVariable<(M + 1), Context> for DelayedPublicMutable<T, InitialDelay, Context>>::new",
@@ -2556,7 +2928,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "85": {
+    "84": {
       "function_locations": [
         {
           "name": "<impl StateVariable<1, Context> for Map<K, V, Context>>::new",
@@ -2574,7 +2946,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/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"
     },
-    "91": {
+    "90": {
       "function_locations": [
         {
           "name": "WithHash<T, M>::new",
@@ -2641,7 +3013,7 @@
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "rVjbbts6EPwXPfuBe+Mlv1IUgZM4hQHDCdzkAAdB/r27MZeyC5BN2L5Y45E1Gi6HS1lvy8Pu7vXH7f74+PRzufn2ttyd9ofD/sft4el++7J/Oir7tgT7iPpJmyXKcsObJYXzIX8cMi03UQ/6DfQ3JZ2PELACJAd+ivwUOcPOsDMCDqQCM3EG7KBUkPwWqbqAbIJiIFZQwEFlMIADZ8AZMBs6KkR04AzZb7KBWAEbUwzECsQZKRWYZyQDyqAxSRkCBWaV7FROFRRj2IAx6oeIHejlpDaI2YExSYEYkw0Yo7cgu+kZOGM35WCgVJCNAQOlguJMsQnGzcJBy8tkwBg1xiwViGVBDEgFNk0cDRijxvgjL9mAVJCdycaoMS7BgTKixiQEB+pHwIA6FPUjYAwZMEZtCLIDY9SGWMXOwBl2xiom6lCsYmfgTHTGKiZqXqxiUt7fN4svi9uX025nq+Jinejqed6edseX5eb4ejhslv+2h9ePH/183h4/ji/bk57VAe2OD3pUwcf9YWfofbNeHfqXgsYh1ssVl9wkuFxpQF+jRIAqUSJhU5B0pYADFyE3ExBKU0hfGUcsLkEhht44RhoE2GwQUOlpSF+D2F3oQpkZB4WSVg8oPQ9pVAtbMz6lq0KWK4XcV8DskaKLRCDglUAZRIKCWyjEayQg/ZaqQSlKsPZw1ggl9DVgNB0uQfliIPSbwiCa2rU9EwiZ5zSQ3AZiHPjgvgZD8jlhDOmiGp+2QSVBm9ZUujZG0YJyucp60YKBREJ0iaSb2yrBX5FAlyCAnsTnl5l02x6ORCKzF1RxpJ4RHCQ0695WNTKn2G2eg3mNbU4SpF7P+cNAkqwDKak7kEFA9ekoZBfJmviuiIw2AqTWggNK6tYjDhpHWec2BOCuxiBiUR//qkaE3LcxaqLJy4GluxWMxyG4jgNzzwQNppZE2pqPAbs2xhMbm4+sjb03sTRqgQWlVYPyRfuCL2i0pUI6r5Ma0jboADKloSVoNQ0RJjXaitMORrMa3DQwzWmApKYR46xGbBoJ/oHGrI/SNBBnfZTw9xq5ZQyJ5zQwtozhbE0xt4wRzPrILWOEc+uWaM0YzWaM1nzQbD2uNGZ9rBnT57BZjfD3GmvGmCb7B6+9kGOZ00jse4OWFOc08sXfjcm+rv9TPGMcoN8LP/8YJP0HSxnt+iG0Z/3Al0ZU47t+3d7vT1dvw95N7LTf3h129evj6/H+4uzL/89+xt+mPZ+e7ncPr6edKa2v1OxV0zfQP0S6pXx/t/v9Ag==",
+      "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=",
       "is_unconstrained": true,
       "name": "get_update_delay"
     },
@@ -2657,6 +3029,10 @@
             ],
             "length": 27
           },
+          "12469291177396340830": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          },
           "12579274401768182412": {
             "error_kind": "string",
             "string": "New contract class is not registered"
@@ -2701,11 +3077,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"
     },
@@ -3181,6 +3557,12 @@
                     "sign": "unsigned",
                     "width": 32
                   }
+                },
+                {
+                  "name": "tx_request_salt",
+                  "type": {
+                    "kind": "field"
+                  }
                 }
               ],
               "kind": "struct",
@@ -4578,6 +4960,12 @@
                   "kind": "struct",
                   "path": "aztec::protocol_types::utils::arrays::claimed_length_array::ClaimedLengthArray"
                 }
+              },
+              {
+                "name": "tx_request_salt",
+                "type": {
+                  "kind": "field"
+                }
               }
             ],
             "kind": "struct",
@@ -4586,18 +4974,22 @@
           "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/I7fuFtO946mnnX7GmZ3OOvucc887/4ILO3eJ7RrXrXuPnr0u6t2nb7/+Fw8YOGjwkEsuvezyK668amj81QnDEpN8w0eM9F9zbfKolNS06wLpGZmjr79hzNgbbxp38y12vM2yt9rb7O32DnunvcvebSfYe+y99j470d5vH7DZNscGba6dZB+0D9mH7SN2sn3UPmYft0/YJ+0U+5R92k610+x0O8POtLPsbPuMnWPn2mftPDvfPmcX2OftQrvILrYv2BftS/Zlu8S+Yl+1S+0y+5p93S63b9g37Vt2hX3brrTv2HftKvueXW2thV1j19p1dr3dYDfa9+0H9kO7yX5kN9uP7Sd2i91qt9nt9lO7w+60u+xuu8d+Zj+3X9gv7Vf2a/uN/dZ+Z7+3e+0P9kf7k/3Z/mJ/tb/Z3+0f9k/7l/3b/mP/tfsgMRCBKMRAqkCqQqpBqkNqQGpCDoEcCjkMUgtSG1IHUhdyOKQepD7kCEgDyJGQhpCjIEdDjoEcCzkO0gjSGHI8pAnkBMiJkJMgJ0OaQk6BNIM0h7SAtIS0grSGtIG0hbSDtId0gHSEnAo5DXI65AzImZBOkLMgZ0POgZwLOQ9yPuQCyIWQzpAukFhIV0gcpBukO6QHpCekF+QiSG9IH0hfSD9If8jFkAGQgZBBkMGQIZBLIJdCLoNcDrkCciXkKshQSDzkakgCZBgkEZIE8UGGQ0ZARkL8kGsg10KSIaMgKZBUSBrkOkgAkg7JgGRCRkOuh9wAGQMZC7kRchNkHORmyC2Q8ZAsyK2Q2yC3Q+6A3Am5C3I3ZALkHsi9kPsgEyH3Qx6AZENyIEFILmQS5EHIQ5CHIY9AJkMehTwGeRzyBORJyBTIU5CnIVMh0yDTITMgMyGzILMhz0DmQOZCnoXMg8yHPAdZAHkeshCyCLIY8gLkRchLkJchSyCvQF6FLIUsg7wGeR2yHPIG5E3IW5AVkLchKyHvQN6FrIK8B1kNsRBA1kDWQtZB1kM2QDZC3od8APkQsgnyEWQz5GPIJ5AtkK2QbZDtkE8hOyA7IbsguyF7IJ9BPod8AfkS8hXka8g3kG8h30G+h+yF/AD5EfIT5GfIL5BfIb9Bfof8AfkT8hfkb8g/kH8h+6AxUIEq1ECrQKtCq0GrQ2tAa0IPgR4KPQxaC1obWgdaF3o4tB60PvQIaAPokdCG0KOgR0OPgR4LPQ7aCNoYejy0CfQE6InQk6AnQ5tCT4E2gzaHtoC2hLaCtoa2gbaFtoO2h3aAdoSeCj0Nejr0DOiZ0E7Qs6BnQ8+Bngs9D3o+9ALohdDO0C7QWGhXaBy0G7Q7tAe0J7QX9CJob2gfaF9oP2h/6MXQAdCB0EHQwdAh0Eugl0Ivg14OvQJ6JfQq6FBoPPRqaAJ0GDQRmgT1QYdDR0BHQv3Qa6DXQpOho6Ap0FRoGvQ6aACaDs2AZkJHQ6+H3gAdAx0LvRF6E3Qc9GboLdDx0CzordDboLdD74DeCb0Lejd0AvQe6L3Q+6ATofdDH4BmQ3OgQWgudBL0QehD0Iehj0AnQx+FPgZ9HPoE9EnoFOhT0KehU6HToNOhM6AzobOgs6HPQOdA50Kfhc6Dzoc+B10AfR66ELoIuhj6AvRF6EvQl6FLoK9AX4UuhS6DvgZ9Hboc+gb0Tehb0BXQt6Eroe9A34Wugr4HXQ21UEDXQNdC10HXQzdAN0Lfh34A/RC6CfoRdDP0Y+gn0C3QrdBt0O3QT6E7oDuhu6C7oXugn0E/h34B/RL6FfRr6DfQb6HfQb+H7oX+AP0R+hP0Z+gv0F+hv0F/h/4B/RP6F/Rv6D/Qf6H7YGJg9v8eP4yBqQJTFaYaTHWYGjA1YQ6BORTmMJhaMLVh6sDUhTkcph5MfZgjYBrAHAnTEOYomKNhjoE5FuY4mEYwjWGOh2kCcwLMiTAnwZwM0xTmFJhmMM1hWsC0hGkF0xqmDUxbmHYw7WE6wHT0zuy983XvLNw7t/bOmL3zYO/s1jtn9c5EvfNL76zROxf0zvC88zbvbMw7x/LOnLzzIe8sxzt38c5IvPMM7+zBOyfw9vS9/Xdvr9zb1/b2oL39Ym9v19uH9fZMvf1Nby/S2zf09vi8/Thv78zb5/L2pLz9I2+vx9uX8fZQvP0Ob2/C20fw1vze+txbS3vrXm+N6q0nvbWft07z1lTe+sdbq3jrCm8N4M3Xvbm1Nw/25qze/NKbC3rzNm+O5c115gzwZWQGUromZCRsiekYI2qqVK1WvUbNQw49rFbtOnUPr1f/iAZHNjzq6GOOPa5R4+ObnHDiSSc3PaVZ8xYtW7Vu07Zd+w7Z2ZODWdM7J/oDJwXXrqv+9c+rV47Izj74UdPiH7Up/lFccG3N35cNnfBN7Yz8j7oF166Kqf5JxpVx8/M/uiy4dt6hG7osm1JjaP5HVxT/6Ori+MSwjx4Obm6ecGDSGJ+YOiotIcM/LNkXnxpISPT+N9oXSPenpsRfH0hIS/MFtsTUzZoRm5qSnpGbNbOrP+BLzNCsWT1TMnwjfIFpg0/tWPZcsuj3Jarvj48r+v2Y6PLHZU2PTUhOzjm0gDN7gC/Zu+jRviivJKY4wURLeHZ/XZK8fhabmjam4JLiwusUBs+ree0K1zyuEmo+fWBGalpOMEJNi9yj2Bnd/L7ksvfMGhf9YlfHL8bMzBuyWXO7pQZ8/hEp+1vqQa9fj83wJcaP8qcnxud18diCHt7vQAcfkte/9w+MeXnLl85JSQFfenpB1SN83jWYNXOgf1Rasi+vioX/dLA6wcX+9PiUzORk/3C/LxCf5ktJ8qeM+O8HUbcKDqJuxTtQlegIWpxQtXIGT2x4ncLg0/qkji7UXQvii/zEFNzigwOu1sGIkkZnRQdSXIVbUooPRRMOKzQiluYNiLTA6Hh/et/8jtk/r1/mFO3qIUpOfvcuqNvUwR2CEeM14k9MqcOm+E0KVSF/SM1P8u1/TaWm++JH+lMytsQ0+N8bTKa8V1DeTuQwmAp1qsiDqcQh0zU8NNJgMhW+iq4Vfqho8cFU6CHiXV2RCpbwDp4+uEPHTsVCw9vvYG+f18WfkhAYc+AP/dImhQVMG5g5rIxXa+in+e/I+h1iNh2//fQxrY48I7Xf6Nu3D5p38xHTWnxe56jvMs8d/ceW1Mj5qk7rk5kc4aoiD0lT/MkZIuYP19nJGfkDteH/v/X+/6134D/+Wy9yV58Zd11mQnJ6hB49s1fmqLSew8OwVetlTd//YU7dUsbr7N7eW27QyISUSDP3A4QGpc3cvReqw1UXuWuFRmp+EoeX6OamKakZ/uFj4hMDvoQMX1LYJPXgwi8tkHrDmCf+4xHbtYIjtuv/4Ku14gvXirdKWcu/wquwJqFJZ16vi83rdAXzz+zsyFNPzSl5ZbUwOXVEfl8t2Jy4+D/ur2kV7K9pFX4/tClOqFbp/bVqOPzgPKcgqqAQerB1KhLUNVSIHBQXKkQO6hYqRA7qHipEDuoRKkQO6hkqRA7qFSpEDrooVIgc1DtUiBzUJ1SIHNQ3VIgc1C9UiBzUP1SIHHRxqBA5aECoEDloYKgQOWhQqBA5aHCoEDloSKgQOeiSUCFy0KWhQuSgy0KFyEGXhwqRg64IFSIHXRkqRA66KlSIHDQ0VIgcFB8qRA66OlQID4r8Fqzou6trhZ+QjYrWrmrodVGMXT06duOsuXmTTO9L/dIeLABP816M+wGhTGEZ5vX09m8OtE7FXh5SJHkoRUH64tdcZEFviq8PD/6kSniVC/2k6PvEm+V0Lm1tWeE5WUKF+0AdYh+o+z/UB6pUZh8ouhXjxfSu8Gw4jT8bLuluVi96N02oJQo1TI1QQKHPa4baNG/h1zNreu/UhKSCgGohwgyvfgFf8a9WK7luNYrWrUboRpf4hZpFv1CzjC8cUrBgLjFN9dA6PP8LcfknPBWdIdeJ1MGrFe/gJtJllDYqqoR9KXwdND/sMMpbvGRnTypl//yZHr6EtM6BQMKYsF5VrVHEb1Qt+RvV60wqYee+U9aMvMCStvU7NSr24YHrK/qVvOVYnfz12IK8p4+XM96f4p0aZ0wuuhZqUMG12BGVs46JCdWnAFx01eh66lhsRyh/qOZvMhXNqcU6tqlRbM3pmF0iZY+Z1tU/OvSSKKhD/lOq4LLzG+L/AA//PibufwEA",
       "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": {
         "error_types": {
+          "12469291177396340830": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          },
           "13455385521185560676": {
             "error_kind": "string",
             "string": "Storage slot 0 not allowed. Storage slots must start from 1."
@@ -4636,17 +5028,21 @@
         ],
         "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": "set_update_delay"
     },
     {
       "abi": {
         "error_types": {
+          "12469291177396340830": {
+            "error_kind": "string",
+            "string": "call to assert_max_bit_size"
+          },
           "12579274401768182412": {
             "error_kind": "string",
             "string": "New contract class is not registered"
@@ -4692,17 +5088,17 @@
         ],
         "return_type": null
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "custom_attributes": [
         "abi_public"
       ],
-      "debug_symbols": "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",
+      "debug_symbols": "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",
       "is_unconstrained": true,
       "name": "update"
     }
   ],
   "name": "ContractInstanceRegistry",
-  "noir_version": "1.0.0-beta.21+f1a4575adac59af0a86b036cf73ff5883d142a91",
+  "noir_version": "1.0.0-beta.22+c57152f91260ecdb9faad4efc20abb14b6d2ece7",
   "outputs": {
     "globals": {},
     "structs": {
@@ -5128,5 +5524,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "6.0.0-nightly.20260604"
+  "aztec_version": "6.0.0-nightly.20260721"
 }