@aztec/protocol-contracts 0.0.1-commit.2f68f620 → 0.0.1-commit.321f6a9

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,10 +95,174 @@
         {
           "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": {
       "function_locations": [
@@ -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,35 +394,35 @@
         },
         {
           "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": {
       "function_locations": [
@@ -364,183 +532,235 @@
         },
         {
           "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::zero_field_to_bytes_zero_limbs_unconstrained",
+          "start": 19600
+        },
+        {
+          "name": "tests::zero_field_to_bytes_zero_limbs_constrained",
+          "start": 19915
+        },
+        {
+          "name": "tests::zero_field_to_bytes_zero_limbs_comptime",
+          "start": 20227
         },
         {
           "name": "tests::test_field_less_than",
-          "start": 17214
+          "start": 20558
         },
         {
           "name": "tests::test_large_field_values_unconstrained",
-          "start": 17469
+          "start": 20813
         },
         {
           "name": "tests::test_large_field_values",
-          "start": 17922
+          "start": 21266
         },
         {
           "name": "tests::test_decomposition_edge_cases",
-          "start": 18369
+          "start": 21713
         },
         {
           "name": "tests::test_pow_32",
-          "start": 18959
+          "start": 22303
         },
         {
           "name": "tests::test_sgn0",
-          "start": 19288
+          "start": 22632
         },
         {
           "name": "tests::test_bit_decomposition_overflow",
-          "start": 19710
+          "start": 23054
         },
         {
           "name": "tests::test_byte_decomposition_overflow",
-          "start": 19992
+          "start": 23336
         },
         {
           "name": "tests::test_to_from_be_bytes_bn254_edge_cases",
-          "start": 20209
+          "start": 23553
         },
         {
           "name": "tests::test_to_from_le_bytes_bn254_edge_cases",
-          "start": 22160
+          "start": 25504
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_accepts_modulus_minus_one",
+          "start": 27439
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_rejects_modulus",
+          "start": 27918
+        },
+        {
+          "name": "tests::test_from_le_bytes_checked_rejects_modulus_plus_one",
+          "start": 28303
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_accepts_modulus_minus_one",
+          "start": 28758
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_rejects_modulus",
+          "start": 29247
+        },
+        {
+          "name": "tests::test_from_be_bytes_checked_rejects_modulus_plus_one",
+          "start": 29632
+        },
+        {
+          "name": "tests::test_from_bytes_checked_small_n",
+          "start": 30076
         },
         {
           "name": "tests::from_le_bits",
-          "start": 24245
+          "start": 30721
         },
         {
           "name": "tests::from_be_bits",
-          "start": 24792
+          "start": 31268
         },
         {
           "name": "tests::test_to_from_be_bits_bn254_edge_cases",
-          "start": 25038
+          "start": 31514
         },
         {
           "name": "tests::test_to_from_le_bits_bn254_edge_cases",
-          "start": 26971
+          "start": 33447
         },
         {
           "name": "tests::max_bit_size_too_large",
-          "start": 28903
+          "start": 35379
         }
       ],
       "path": "std/field/mod.nr",
-      "source": "pub mod bn254;\nuse crate::{runtime::is_unconstrained, static_assert};\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    /// Asserts that `self` can be represented in `bit_size` bits.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^{bit_size}`.\n    // docs:start:assert_max_bit_size\n    pub fn assert_max_bit_size<let BIT_SIZE: u32>(self) {\n        // docs:end:assert_max_bit_size\n        static_assert(\n            BIT_SIZE < modulus_num_bits() as u32,\n            \"BIT_SIZE must be less than modulus_num_bits\",\n        );\n        __assert_max_bit_size(self, BIT_SIZE);\n    }\n\n    /// Decomposes `self` into its little endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_le_bits\n    pub fn to_le_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_le_bits\n        let bits = __to_le_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[N - 1 - i] != p[N - 1 - i]) {\n                        assert(p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its big endian bit decomposition as a `[bool; N]` array.\n    /// This array will be zero padded should not all bits be necessary to represent `self`.\n    ///\n    /// # Failures\n    /// Causes a constraint failure for `Field` values exceeding `2^N` as the resulting array will not\n    /// be able to represent the original `Field`.\n    ///\n    /// # Safety\n    /// The bit decomposition returned is canonical and is guaranteed to not overflow the modulus.\n    // docs:start:to_be_bits\n    pub fn to_be_bits<let N: u32>(self: Self) -> [bool; N] {\n        // docs:end:to_be_bits\n        let bits = __to_be_bits(self);\n\n        if !is_unconstrained() {\n            // Ensure that the decomposition does not overflow the modulus\n            let p = modulus_be_bits();\n            assert(bits.len() <= p.len());\n            let mut ok = bits.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bits[i] != p[i]) {\n                        assert(p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bits\n    }\n\n    /// Decomposes `self` into its little endian byte decomposition as a `[u8;N]` array\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_le_bytes\n    pub fn to_le_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_le_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_le_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_le_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[N - 1 - i] != p[N - 1 - i]) {\n                        assert(bytes[N - 1 - i] < p[N - 1 - i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    /// Decomposes `self` into its big endian byte decomposition as a `[u8;N]` array of length required to represent the field modulus\n    /// This array will be zero padded should not all bytes be necessary to represent `self`.\n    ///\n    /// # Failures\n    ///  The length N of the array must be big enough to contain all the bytes of the 'self',\n    ///  and no more than the number of bytes required to represent the field modulus\n    ///\n    /// # Safety\n    /// The result is ensured to be the canonical decomposition of the field element\n    // docs:start:to_be_bytes\n    pub fn to_be_bytes<let N: u32>(self: Self) -> [u8; N] {\n        // docs:end:to_be_bytes\n        static_assert(\n            N <= modulus_le_bytes().len(),\n            \"N must be less than or equal to modulus_le_bytes().len()\",\n        );\n        // Compute the byte decomposition\n        let bytes = self.to_be_radix(256);\n\n        if !is_unconstrained() {\n            // Ensure that the byte decomposition does not overflow the modulus\n            let p = modulus_be_bytes();\n            assert(bytes.len() <= p.len());\n            let mut ok = bytes.len() != p.len();\n            for i in 0..N {\n                if !ok {\n                    if (bytes[i] != p[i]) {\n                        assert(bytes[i] < p[i]);\n                        ok = true;\n                    }\n                }\n            }\n            assert(ok);\n        }\n        bytes\n    }\n\n    fn to_le_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_le_radix(self, radix)\n    }\n\n    fn to_be_radix<let N: u32>(self: Self, radix: u32) -> [u8; N] {\n        // Brillig does not need an immediate radix\n        if !crate::runtime::is_unconstrained() {\n            static_assert(1 < radix, \"radix must be greater than 1\");\n            static_assert(radix <= 256, \"radix must be less than or equal to 256\");\n            static_assert(radix & (radix - 1) == 0, \"radix must be a power of 2\");\n        }\n        __to_be_radix(self, radix)\n    }\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b: [bool; 32] = exponent.to_le_bits();\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32 - i] as Field) * (r * self) + (1 - b[32 - i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = false if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = true.\n    pub fn sgn0(self) -> bool {\n        (self as u8) % 2 == 1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n\n    /// Convert a little endian byte array to a field element.\n    /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n    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 zero_field_to_bytes_zero_limbs_unconstrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_constrained() {\n        assert_eq((0 as Field).to_le_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bytes::<0>().len(), 0);\n        assert_eq((0 as Field).to_le_bits::<0>().len(), 0);\n        assert_eq((0 as Field).to_be_bits::<0>().len(), 0);\n    }\n\n    #[test]\n    fn zero_field_to_bytes_zero_limbs_comptime() {\n        let _: [u8; 0] = comptime { (0 as Field).to_le_bytes() };\n        let _: [u8; 0] = comptime { (0 as Field).to_be_bytes() };\n        let _: [bool; 0] = comptime { (0 as Field).to_le_bits() };\n        let _: [bool; 0] = comptime { (0 as Field).to_be_bits() };\n    }\n\n    #[test]\n    unconstrained fn test_field_less_than() {\n        assert(field_less_than(0, 1));\n        assert(field_less_than(0, 0x100));\n        assert(field_less_than(0x100, 0 - 1));\n        assert(!field_less_than(0 - 1, 0));\n    }\n\n    #[test]\n    unconstrained fn test_large_field_values_unconstrained() {\n        let large_field = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_field.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_field.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_field);\n\n        let radix_bytes: [u8; 8] = large_field.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_field);\n    }\n\n    #[test]\n    fn test_large_field_values() {\n        let large_val = 0xffffffffffffffff;\n\n        let bits: [bool; 64] = large_val.to_le_bits();\n        assert_eq(bits[0], true);\n\n        let bytes: [u8; 8] = large_val.to_le_bytes();\n        assert_eq(Field::from_le_bytes::<8>(bytes), large_val);\n\n        let radix_bytes: [u8; 8] = large_val.to_le_radix(256);\n        assert_eq(Field::from_le_bytes::<8>(radix_bytes), large_val);\n    }\n\n    #[test]\n    fn test_decomposition_edge_cases() {\n        let zero_bits: [bool; 8] = 0.to_le_bits();\n        assert_eq(zero_bits, [false; 8]);\n\n        let zero_bytes: [u8; 8] = 0.to_le_bytes();\n        assert_eq(zero_bytes, [0; 8]);\n\n        let one_bits: [bool; 8] = 1.to_le_bits();\n        let expected: [bool; 8] = [true, false, false, false, false, false, false, false];\n        assert_eq(one_bits, expected);\n\n        let pow2_bits: [bool; 8] = 4.to_le_bits();\n        let expected: [bool; 8] = [false, false, true, false, false, false, false, false];\n        assert_eq(pow2_bits, expected);\n    }\n\n    #[test]\n    fn test_pow_32() {\n        assert_eq(2.pow_32(3), 8);\n        assert_eq(3.pow_32(2), 9);\n        assert_eq(5.pow_32(0), 1);\n        assert_eq(7.pow_32(1), 7);\n\n        assert_eq(2.pow_32(10), 1024);\n\n        assert_eq(0.pow_32(5), 0);\n        assert_eq(0.pow_32(0), 1);\n\n        assert_eq(1.pow_32(100), 1);\n    }\n\n    #[test]\n    fn test_sgn0() {\n        assert_eq(0.sgn0(), false);\n        assert_eq(2.sgn0(), false);\n        assert_eq(4.sgn0(), false);\n        assert_eq(100.sgn0(), false);\n\n        assert_eq(1.sgn0(), true);\n        assert_eq(3.sgn0(), true);\n        assert_eq(5.sgn0(), true);\n        assert_eq(101.sgn0(), true);\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 8 limbs\")]\n    fn test_bit_decomposition_overflow() {\n        // 8 bits can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [bool; 8] = large_val.to_le_bits();\n    }\n\n    #[test(should_fail_with = \"Field failed to decompose into specified 4 limbs\")]\n    fn test_byte_decomposition_overflow() {\n        // 4 bytes can't represent large field values\n        let large_val = 0x1000000000000000;\n        let _: [u8; 4] = large_val.to_le_bytes();\n    }\n\n    #[test]\n    fn test_to_from_be_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 BE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n\n            let p_minus_1 = Field::from_be_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_be_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 BE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n\n            let p_plus_1 = Field::from_be_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 BE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_be_bytes();\n            assert_eq(p_plus_1_converted_bytes[32 - 1], 1);\n            p_plus_1_converted_bytes[32 - 1] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_be_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_be_bytes().len(), 32);\n            let p = Field::from_be_bytes::<32>(modulus_be_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 BE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_be_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bytes_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this byte produces the expected 32 LE bytes for (modulus - 1)\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n\n            let p_minus_1 = Field::from_le_bytes::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 32 BE bytes produces the same bytes\n            let p_minus_1_converted_bytes: [u8; 32] = p_minus_1.to_le_bytes();\n            assert_eq(p_minus_1_converted_bytes, p_minus_1_bytes);\n\n            // checking that incrementing this byte produces 32 LE bytes for (modulus + 1)\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n\n            let p_plus_1 = Field::from_le_bytes::<32>(p_plus_1_bytes);\n            assert_eq(p_plus_1, 1);\n\n            // checking that converting p_plus_1 to 32 LE bytes produces the same\n            // byte set to 1 as p_plus_1_bytes and otherwise zeroes\n            let mut p_plus_1_converted_bytes: [u8; 32] = p_plus_1.to_le_bytes();\n            assert_eq(p_plus_1_converted_bytes[0], 1);\n            p_plus_1_converted_bytes[0] = 0;\n            assert_eq(p_plus_1_converted_bytes, [0; 32]);\n\n            // checking that Field::from_le_bytes::<32> on the Field modulus produces 0\n            assert_eq(modulus_le_bytes().len(), 32);\n            let p = Field::from_le_bytes::<32>(modulus_le_bytes().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 32 LE bytes produces 32 zeroes\n            let p_bytes: [u8; 32] = 0.to_le_bytes();\n            assert_eq(p_bytes, [0; 32]);\n        }\n    }\n\n    #[test]\n    fn test_from_le_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_minus_1_bytes[0] > 0);\n            p_minus_1_bytes[0] -= 1;\n            let p_minus_1 = Field::from_le_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_le_bytes_checked::<32>(modulus_le_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_le_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_le_bytes().as_array();\n            assert(p_plus_1_bytes[0] < 255);\n            p_plus_1_bytes[0] += 1;\n            let _ = Field::from_le_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_be_bytes_checked_accepts_modulus_minus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_minus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_minus_1_bytes[32 - 1] > 0);\n            p_minus_1_bytes[32 - 1] -= 1;\n            let p_minus_1 = Field::from_be_bytes_checked::<32>(p_minus_1_bytes);\n            assert_eq(p_minus_1 + 1, 0);\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus() {\n        if crate::compat::is_bn254() {\n            let _ = Field::from_be_bytes_checked::<32>(modulus_be_bytes().as_array());\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test(should_fail_with = \"input bytes are not a canonical field representation\")]\n    fn test_from_be_bytes_checked_rejects_modulus_plus_one() {\n        if crate::compat::is_bn254() {\n            let mut p_plus_1_bytes: [u8; 32] = modulus_be_bytes().as_array();\n            assert(p_plus_1_bytes[32 - 1] < 255);\n            p_plus_1_bytes[32 - 1] += 1;\n            let _ = Field::from_be_bytes_checked::<32>(p_plus_1_bytes);\n        } else {\n            panic(\"input bytes are not a canonical field representation\");\n        }\n    }\n\n    #[test]\n    fn test_from_bytes_checked_small_n() {\n        // For N < modulus_bytes().len(), the input cannot overflow the modulus, so the checked\n        // variants behave identically to the unchecked ones.\n        let le_bytes: [u8; 8] = [3, 1, 0, 0, 0, 0, 0, 0];\n        assert_eq(Field::from_le_bytes_checked::<8>(le_bytes), 259);\n        let be_bytes: [u8; 8] = [0, 0, 0, 0, 0, 0, 1, 3];\n        assert_eq(Field::from_be_bytes_checked::<8>(be_bytes), 259);\n    }\n\n    /// Convert a little endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_le_bits<let N: u32>(bits: [bool; N]) -> Field {\n        static_assert(\n            N <= modulus_le_bits().len(),\n            \"N must be less than or equal to modulus_le_bits().len()\",\n        );\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    /// Convert a big endian bit array to a field element.\n    /// If the provided bit array overflows the field modulus then the Field will silently wrap around.\n    fn from_be_bits<let N: u32>(bits: [bool; N]) -> Field {\n        let mut v = 1;\n        let mut result = 0;\n\n        for i in 0..N {\n            result += (bits[N - 1 - i] as Field) * v;\n            v = v * 2;\n        }\n        result\n    }\n\n    #[test]\n    fn test_to_from_be_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 BE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(p_minus_1_bits[254 - 1]);\n            p_minus_1_bits[254 - 1] = false;\n\n            let p_minus_1 = from_be_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_be_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 BE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_be_bits().as_array();\n            assert(!p_plus_4_bits[254 - 3]);\n            p_plus_4_bits[254 - 3] = true;\n\n            let p_plus_4 = from_be_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 BE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_be_bits();\n            assert(p_plus_4_converted_bits[254 - 3]);\n            p_plus_4_converted_bits[254 - 3] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_be_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_be_bits().len(), 254);\n            let p = from_be_bits::<254>(modulus_be_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 BE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_be_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test]\n    fn test_to_from_le_bits_bn254_edge_cases() {\n        if crate::compat::is_bn254() {\n            // checking that decrementing this bit produces the expected 254 LE bits for (modulus - 1)\n            let mut p_minus_1_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(p_minus_1_bits[0]);\n            p_minus_1_bits[0] = false;\n\n            let p_minus_1 = from_le_bits::<254>(p_minus_1_bits);\n            assert_eq(p_minus_1 + 1, 0);\n\n            // checking that converting (modulus - 1) from and then to 254 BE bits produces the same bits\n            let p_minus_1_converted_bits: [bool; 254] = p_minus_1.to_le_bits();\n            assert_eq(p_minus_1_converted_bits, p_minus_1_bits);\n\n            // checking that incrementing this bit produces 254 LE bits for (modulus + 4)\n            let mut p_plus_4_bits: [bool; 254] = modulus_le_bits().as_array();\n            assert(!p_plus_4_bits[2]);\n            p_plus_4_bits[2] = true;\n\n            let p_plus_4 = from_le_bits::<254>(p_plus_4_bits);\n            assert_eq(p_plus_4, 4);\n\n            // checking that converting p_plus_4 to 254 LE bits produces the same\n            // bit set to 1 as p_plus_4_bits and otherwise zeroes\n            let mut p_plus_4_converted_bits: [bool; 254] = p_plus_4.to_le_bits();\n            assert(p_plus_4_converted_bits[2]);\n            p_plus_4_converted_bits[2] = false;\n            assert_eq(p_plus_4_converted_bits, [false; 254]);\n\n            // checking that Field::from_le_bits::<254> on the Field modulus produces 0\n            assert_eq(modulus_le_bits().len(), 254);\n            let p = from_le_bits::<254>(modulus_le_bits().as_array());\n            assert_eq(p, 0);\n\n            // checking that converting 0 to 254 LE bits produces 254 false values\n            let p_bits: [bool; 254] = 0.to_le_bits();\n            assert_eq(p_bits, [false; 254]);\n        }\n    }\n\n    #[test(should_fail_with = \"call to assert_max_bit_size\")]\n    fn max_bit_size_too_large() {\n        let x: Field = 0x010000;\n        x.assert_max_bit_size::<16>();\n    }\n\n}\n"
     },
     "17": {
       "function_locations": [
@@ -552,149 +772,181 @@
           "name": "keccakf1600",
           "start": 707
         },
-        {
-          "name": "keccak::keccakf1600",
-          "start": 882
-        },
         {
           "name": "blake2s",
-          "start": 1044
+          "start": 852
         },
         {
           "name": "blake3",
-          "start": 1142
+          "start": 950
         },
         {
           "name": "__blake3",
-          "start": 1629
+          "start": 1437
         },
         {
           "name": "pedersen_commitment",
-          "start": 1747
+          "start": 1555
         },
         {
           "name": "pedersen_commitment_with_separator",
-          "start": 1976
+          "start": 1784
         },
         {
           "name": "pedersen_hash",
-          "start": 2380
+          "start": 2188
         },
         {
           "name": "pedersen_hash_with_separator",
-          "start": 2537
+          "start": 2345
         },
         {
           "name": "derive_generators",
-          "start": 3531
+          "start": 3339
         },
         {
           "name": "__derive_generators",
-          "start": 3890
+          "start": 3698
         },
         {
           "name": "poseidon2_permutation",
-          "start": 3968
+          "start": 3776
         },
         {
           "name": "poseidon2_permutation_internal",
-          "start": 4324
+          "start": 4132
         },
         {
           "name": "poseidon2_config_state_size",
-          "start": 4417
+          "start": 4225
         },
         {
           "name": "derive_hash",
-          "start": 4728
+          "start": 4536
+        },
+        {
+          "name": "Hasher::finish_ref",
+          "start": 5327
         },
         {
           "name": "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher",
-          "start": 5953
+          "start": 5761
         },
         {
           "name": "<impl Default for BuildHasherDefault<H>>::default",
-          "start": 6085
+          "start": 5893
         },
         {
           "name": "<impl Hash for Field>::hash",
-          "start": 6217
+          "start": 6025
         },
         {
           "name": "<impl Hash for u8>::hash",
-          "start": 6347
+          "start": 6155
         },
         {
           "name": "<impl Hash for u16>::hash",
-          "start": 6487
+          "start": 6295
         },
         {
           "name": "<impl Hash for u32>::hash",
-          "start": 6627
+          "start": 6435
         },
         {
           "name": "<impl Hash for u64>::hash",
-          "start": 6767
+          "start": 6575
         },
         {
           "name": "<impl Hash for u128>::hash",
-          "start": 6908
+          "start": 6716
         },
         {
           "name": "<impl Hash for i8>::hash",
-          "start": 7047
+          "start": 6855
         },
         {
           "name": "<impl Hash for i16>::hash",
-          "start": 7193
+          "start": 7001
         },
         {
           "name": "<impl Hash for i32>::hash",
-          "start": 7340
+          "start": 7148
         },
         {
           "name": "<impl Hash for i64>::hash",
-          "start": 7487
+          "start": 7295
         },
         {
           "name": "<impl Hash for bool>::hash",
-          "start": 7635
+          "start": 7443
         },
         {
           "name": "<impl Hash for ()>::hash",
-          "start": 7782
+          "start": 7590
         },
         {
           "name": "<impl Hash for [T; N]>::hash",
-          "start": 7914
+          "start": 7722
         },
         {
           "name": "<impl Hash for [T]>::hash",
-          "start": 8103
+          "start": 7911
+        },
+        {
+          "name": "<impl Hash for (A,)>::hash",
+          "start": 8133
         },
         {
           "name": "<impl Hash for (A, B)>::hash",
-          "start": 8343
+          "start": 8302
         },
         {
           "name": "<impl Hash for (A, B, C)>::hash",
-          "start": 8559
+          "start": 8518
         },
         {
           "name": "<impl Hash for (A, B, C, D)>::hash",
-          "start": 8822
+          "start": 8781
         },
         {
           "name": "<impl Hash for (A, B, C, D, E)>::hash",
-          "start": 9132
+          "start": 9091
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F)>::hash",
+          "start": 9448
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G)>::hash",
+          "start": 9852
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash",
+          "start": 10306
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash",
+          "start": 10807
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash",
+          "start": 11355
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash",
+          "start": 11950
+        },
+        {
+          "name": "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash",
+          "start": 12593
         },
         {
           "name": "assert_pedersen",
-          "start": 9528
+          "start": 13187
         }
       ],
       "path": "std/hash/mod.nr",
-      "source": "// Exposed only for usage in `std::meta`\npub(crate) mod poseidon2;\n\nuse crate::default::Default;\nuse crate::embedded_curve_ops::{\n    EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul, multi_scalar_mul_array_return,\n};\nuse crate::meta::derive_via;\nuse crate::static_assert;\n\n/// The size of the state accepted by the backend in `poseidon2_permutation`.\nglobal POSEIDON2_CONFIG_STATE_SIZE: u32 = poseidon2_config_state_size();\n\n#[foreign(sha256_compression)]\n// docs:start:sha256_compression\npub fn sha256_compression(input: [u32; 16], state: [u32; 8]) -> [u32; 8] {}\n// docs:end:sha256_compression\n\n#[foreign(keccakf1600)]\n// docs:start:keccakf1600\npub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {}\n// docs:end:keccakf1600\n\npub mod keccak {\n    #[deprecated(\"This function has been moved to std::hash::keccakf1600\")]\n    pub fn keccakf1600(input: [u64; 25]) -> [u64; 25] {\n        super::keccakf1600(input)\n    }\n}\n\n#[foreign(blake2s)]\n// docs:start:blake2s\npub fn blake2s<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake2s\n{}\n\n// docs:start:blake3\npub fn blake3<let N: u32>(input: [u8; N]) -> [u8; 32]\n// docs:end:blake3\n{\n    if crate::runtime::is_unconstrained() {\n        // Temporary measure while Barretenberg is main proving system.\n        // Please open an issue if you're working on another proving system and running into problems due to this.\n        crate::static_assert(\n            N <= 1024,\n            \"Barretenberg cannot prove blake3 hashes with inputs larger than 1024 bytes\",\n        );\n    }\n    __blake3(input)\n}\n\n#[foreign(blake3)]\nfn __blake3<let N: u32>(input: [u8; N]) -> [u8; 32] {}\n\n// docs:start:pedersen_commitment\npub fn pedersen_commitment<let N: u32>(input: [Field; N]) -> EmbeddedCurvePoint {\n    // docs:end:pedersen_commitment\n    pedersen_commitment_with_separator(input, 0)\n}\n\n#[inline_always]\npub fn pedersen_commitment_with_separator<let N: u32>(\n    input: [Field; N],\n    separator: u32,\n) -> EmbeddedCurvePoint {\n    let mut points = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N];\n    for i in 0..N {\n        points[i] = EmbeddedCurveScalar::from_field(input[i]);\n    }\n    let generators = derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n    multi_scalar_mul(generators, points)\n}\n\n// docs:start:pedersen_hash\npub fn pedersen_hash<let N: u32>(input: [Field; N]) -> Field\n// docs:end:pedersen_hash\n{\n    pedersen_hash_with_separator(input, 0)\n}\n\n#[no_predicates]\npub fn pedersen_hash_with_separator<let N: u32>(input: [Field; N], separator: u32) -> Field {\n    let mut scalars: [EmbeddedCurveScalar; N + 1] = [EmbeddedCurveScalar { lo: 0, hi: 0 }; N + 1];\n    let mut generators: [EmbeddedCurvePoint; N + 1] =\n        [EmbeddedCurvePoint::point_at_infinity(); N + 1];\n    crate::assert_constant(separator);\n    let domain_generators: [EmbeddedCurvePoint; N] =\n        derive_generators(\"DEFAULT_DOMAIN_SEPARATOR\".as_bytes(), separator);\n\n    for i in 0..N {\n        scalars[i] = EmbeddedCurveScalar::from_field(input[i]);\n        generators[i] = domain_generators[i];\n    }\n    scalars[N] = EmbeddedCurveScalar { lo: N as Field, hi: 0 as Field };\n\n    let length_generator: [EmbeddedCurvePoint; 1] =\n        derive_generators(\"pedersen_hash_length\".as_bytes(), 0);\n    generators[N] = length_generator[0];\n    multi_scalar_mul_array_return(generators, scalars, true)[0].x\n}\n\n#[field(bn254)]\n#[inline_always]\npub fn derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {\n    crate::assert_constant(domain_separator_bytes);\n    crate::assert_constant(starting_index);\n    __derive_generators(domain_separator_bytes, starting_index)\n}\n\n#[builtin(derive_pedersen_generators)]\n#[field(bn254)]\nfn __derive_generators<let N: u32, let M: u32>(\n    domain_separator_bytes: [u8; M],\n    starting_index: u32,\n) -> [EmbeddedCurvePoint; N] {}\n\npub fn poseidon2_permutation<let N: u32>(input: [Field; N]) -> [Field; N] {\n    static_assert(\n        N == POSEIDON2_CONFIG_STATE_SIZE,\n        f\"the input length must equal the state size in the Poseidon2 config; expected {POSEIDON2_CONFIG_STATE_SIZE}, got {N}\",\n    );\n    poseidon2_permutation_internal(input)\n}\n\n#[foreign(poseidon2_permutation)]\nfn poseidon2_permutation_internal<let N: u32>(input: [Field; N]) -> [Field; N] {}\n\n#[foreign(poseidon2_config_state_size)]\ncomptime fn poseidon2_config_state_size() -> u32 {}\n\n// Generic hashing support.\n// Partially ported and impacted by rust.\n\n// Hash trait shall be implemented per type.\n#[derive_via(derive_hash)]\npub trait Hash {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher;\n}\n\n// docs:start:derive_hash\ncomptime fn derive_hash(s: TypeDefinition) -> Quoted {\n    let name = quote { $crate::hash::Hash };\n    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };\n    let for_each_field = |name| quote { _self.$name.hash(_state); };\n    crate::meta::make_trait_impl(\n        s,\n        name,\n        signature,\n        for_each_field,\n        quote {},\n        |fields| fields,\n    )\n}\n// docs:end:derive_hash\n\n// Hasher trait shall be implemented by algorithms to provide hash-agnostic means.\n// TODO: consider making the types generic here ([u8], [Field], etc.)\npub trait Hasher {\n    fn finish(self) -> Field;\n\n    /// Returns the hash value without consuming the hasher.\n    /// Override this for more efficient implementations that avoid copying.\n    /// TODO: deprecate finish() and replace it\n    fn finish_ref(&self) -> Field {\n        (*self).finish()\n    }\n\n    fn write(&mut self, input: Field);\n}\n\n// BuildHasher is a factory trait, responsible for production of specific Hasher.\npub trait BuildHasher {\n    type H: Hasher;\n\n    fn build_hasher(self) -> H;\n}\n\npub struct BuildHasherDefault<H>;\n\nimpl<H> BuildHasher for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    type H = H;\n\n    fn build_hasher(_self: Self) -> H {\n        H::default()\n    }\n}\n\nimpl<H> Default for BuildHasherDefault<H>\nwhere\n    H: Hasher + Default,\n{\n    fn default() -> Self {\n        BuildHasherDefault {}\n    }\n}\n\nimpl Hash for Field {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self);\n    }\n}\n\nimpl Hash for u8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for u128 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for i8 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u8 as Field);\n    }\n}\n\nimpl Hash for i16 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u16 as Field);\n    }\n}\n\nimpl Hash for i32 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u32 as Field);\n    }\n}\n\nimpl Hash for i64 {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as u64 as Field);\n    }\n}\n\nimpl Hash for bool {\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        H::write(state, self as Field);\n    }\n}\n\nimpl Hash for () {\n    fn hash<H>(_self: Self, _state: &mut H)\n    where\n        H: Hasher,\n    {}\n}\n\nimpl<T, let N: u32> Hash for [T; N]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<T> Hash for [T]\nwhere\n    T: Hash,\n{\n    fn hash<H>(self, state: &mut H)\n    where\n        H: Hasher,\n    {\n        self.len().hash(state);\n        for elem in self {\n            elem.hash(state);\n        }\n    }\n}\n\nimpl<A, 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\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": {
       "function_locations": [
@@ -716,15 +968,15 @@
         },
         {
           "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": {
       "function_locations": [
@@ -1040,39 +1292,39 @@
         },
         {
           "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": {
       "function_locations": [
@@ -1188,23 +1440,23 @@
         },
         {
           "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": {
       "function_locations": [
@@ -1498,29 +1750,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": {
+    "43": {
       "function_locations": [
         {
           "name": "Option<T>::none",
@@ -1613,54 +1865,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"
+    },
+    "44": {
+      "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,199 +2034,281 @@
           "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"
     },
-    "56": {
+    "52": {
+      "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"
+    },
+    "57": {
       "function_locations": [
         {
           "name": "PrivateContext::new",
@@ -1972,61 +2356,61 @@
         },
         {
           "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": {
+    "58": {
       "function_locations": [
         {
           "name": "<impl Eq for PublicContext>::eq",
@@ -2156,7 +2540,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/context/public_context.nr",
       "source": "use crate::{\n    context::gas::GasOpts,\n    hash::{\n        compute_l1_to_l2_message_hash, compute_l1_to_l2_message_nullifier, compute_secret_hash,\n        compute_siloed_nullifier,\n    },\n    oracle::avm,\n};\nuse crate::protocol::{\n    abis::function_selector::FunctionSelector,\n    address::{AztecAddress, EthAddress},\n    constants::{MAX_U32_VALUE, NULL_MSG_SENDER_CONTRACT_ADDRESS},\n    traits::{Empty, FromField, Packable, Serialize, ToField},\n};\n\n/// Minimal PublicContext for protocol contracts going to audit.\npub struct PublicContext {\n    pub args_hash: Option<Field>,\n    pub compute_args_hash: fn() -> Field,\n}\n\nimpl Eq for PublicContext {\n    fn eq(self, other: Self) -> bool {\n        (self.args_hash == other.args_hash)\n        // Can't compare the function compute_args_hash\n    }\n}\n\nimpl PublicContext {\n    pub fn new(compute_args_hash: fn() -> Field) -> Self {\n        PublicContext { args_hash: Option::none(), compute_args_hash }\n    }\n\n    /// Emits a _public_ log that will be visible onchain to everyone.\n    pub fn emit_public_log<T>(_self: Self, log: T)\n    where\n        T: Serialize,\n    {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_public_log(Serialize::serialize(log).as_vector()) };\n    }\n\n    /// Checks if a given note hash exists in the note hash tree at a particular leaf_index.\n    pub fn note_hash_exists(_self: Self, note_hash: Field, leaf_index: u64) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::note_hash_exists(note_hash, leaf_index) }\n    }\n\n    /// Checks if a specific L1-to-L2 message exists in the L1-to-L2 message tree at a particular leaf index.\n    pub fn l1_to_l2_msg_exists(_self: Self, msg_hash: Field, msg_leaf_index: Field) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself TODO(alvaro): Make l1l2msg leaf index a u64 upstream\n        unsafe { avm::l1_to_l2_msg_exists(msg_hash, msg_leaf_index as u64) }\n    }\n\n    /// Returns `true` if an `unsiloed_nullifier` has been emitted by `contract_address`.\n    pub fn nullifier_exists_unsafe(\n        _self: Self,\n        unsiloed_nullifier: Field,\n        contract_address: AztecAddress,\n    ) -> bool {\n        let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::nullifier_exists(siloed_nullifier) }\n    }\n\n    /// Consumes a message sent from Ethereum (L1) to Aztec (L2).\n    pub fn consume_l1_to_l2_message(\n        self: Self,\n        content: Field,\n        secret: Field,\n        sender: EthAddress,\n        leaf_index: Field,\n    ) {\n        let secret_hash = compute_secret_hash(secret);\n        let message_hash = compute_l1_to_l2_message_hash(\n            sender,\n            self.chain_id(),\n            /*recipient=*/\n            self.this_address(),\n            self.version(),\n            content,\n            secret_hash,\n            leaf_index,\n        );\n        let nullifier = compute_l1_to_l2_message_nullifier(message_hash, secret);\n\n        assert(\n            !self.nullifier_exists_unsafe(nullifier, self.this_address()),\n            \"L1-to-L2 message is already nullified\",\n        );\n        assert(\n            self.l1_to_l2_msg_exists(message_hash, leaf_index),\n            \"Tried to consume nonexistent L1-to-L2 message\",\n        );\n\n        self.push_nullifier(nullifier);\n    }\n\n    /// Sends an \"L2 -> L1 message\".\n    pub fn message_portal(_self: Self, recipient: EthAddress, content: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::send_l2_to_l1_msg(recipient, content) };\n    }\n\n    /// Calls a public function on another contract.\n    pub unconstrained fn call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Makes a read-only call to a public function on another contract.\n    pub unconstrained fn static_call_public_function<let N: u32>(\n        _self: Self,\n        contract_address: AztecAddress,\n        function_selector: FunctionSelector,\n        args: [Field; N],\n        gas_opts: GasOpts,\n    ) -> [Field] {\n        let calldata = [function_selector.to_field()].concat(args);\n\n        avm::call_static(\n            gas_opts.l2_gas.unwrap_or(MAX_U32_VALUE),\n            gas_opts.da_gas.unwrap_or(MAX_U32_VALUE),\n            contract_address,\n            calldata,\n        );\n        // Use success_copy to determine whether the call succeeded\n        let success = avm::success_copy();\n\n        let result_data = avm::returndata_copy(0, avm::returndata_size());\n        if !success {\n            // Rethrow the revert data.\n            avm::revert(result_data);\n        }\n        result_data\n    }\n\n    /// Adds a new note hash to the Note Hash Tree.\n    pub fn push_note_hash(_self: Self, note_hash: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_note_hash(note_hash) };\n    }\n\n    /// Adds a new nullifier to the Nullifier Tree.\n    pub fn push_nullifier(_self: Self, nullifier: Field) {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::emit_nullifier(nullifier) };\n    }\n\n    /// Returns the address of the current contract being executed.\n    pub fn this_address(_self: Self) -> AztecAddress {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::address()\n        }\n    }\n\n    /// Returns the contract address that initiated this function call.\n    pub fn maybe_msg_sender(_self: Self) -> Option<AztecAddress> {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        let maybe_msg_sender = unsafe { avm::sender() };\n        if maybe_msg_sender == NULL_MSG_SENDER_CONTRACT_ADDRESS {\n            Option::none()\n        } else {\n            Option::some(maybe_msg_sender)\n        }\n    }\n\n    /// Returns the function selector of the currently-executing function.\n    pub fn selector(_self: Self) -> FunctionSelector {\n        // The selector is the first element of the calldata when calling a public function through dispatch.\n        // Safety: AVM opcodes are constrained by the AVM itself.\n        let raw_selector: [Field; 1] = unsafe { avm::calldata_copy(0, 1) };\n        FunctionSelector::from_field(raw_selector[0])\n    }\n\n    /// Returns the hash of the arguments passed to the current function.\n    pub fn get_args_hash(mut self) -> Field {\n        if !self.args_hash.is_some() {\n            self.args_hash = Option::some((self.compute_args_hash)());\n        }\n\n        self.args_hash.unwrap_unchecked()\n    }\n\n    /// Returns the \"transaction fee\" for the current transaction.\n    pub fn transaction_fee(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::transaction_fee()\n        }\n    }\n\n    /// Returns the chain ID of the current network.\n    pub fn chain_id(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::chain_id()\n        }\n    }\n\n    /// Returns the protocol version.\n    pub fn version(_self: Self) -> Field {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::version()\n        }\n    }\n\n    /// Returns the current block number.\n    pub fn block_number(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::block_number()\n        }\n    }\n\n    /// Returns the timestamp of the current block.\n    pub fn timestamp(_self: Self) -> u64 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::timestamp()\n        }\n    }\n\n    /// Returns the fee per unit of L2 gas.\n    pub fn min_fee_per_l2_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_l2_gas()\n        }\n    }\n\n    /// Returns the fee per unit of DA gas.\n    pub fn min_fee_per_da_gas(_self: Self) -> u128 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::min_fee_per_da_gas()\n        }\n    }\n\n    /// Returns the remaining L2 gas available.\n    pub fn l2_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::l2_gas_left()\n        }\n    }\n\n    /// Returns the remaining DA gas available.\n    pub fn da_gas_left(_self: Self) -> u32 {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe {\n            avm::da_gas_left()\n        }\n    }\n\n    /// Checks if the current execution is within a staticcall context.\n    pub fn is_static_call(_self: Self) -> bool {\n        // Safety: AVM opcodes are constrained by the AVM itself\n        unsafe { avm::is_static_call() }\n    }\n\n    /// Reads raw field values from public storage.\n    pub fn raw_storage_read<let N: u32>(self: Self, storage_slot: Field) -> [Field; N] {\n        let mut out = [0; N];\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            out[i] = unsafe {\n                avm::storage_read(storage_slot + i as Field, self.this_address().to_field())\n            };\n        }\n        out\n    }\n\n    /// Reads a typed value from public storage.\n    pub fn storage_read<T>(self, storage_slot: Field) -> T\n    where\n        T: Packable,\n    {\n        T::unpack(self.raw_storage_read(storage_slot))\n    }\n\n    /// Writes raw field values to public storage.\n    pub fn raw_storage_write<let N: u32>(_self: Self, storage_slot: Field, values: [Field; N]) {\n        for i in 0..N {\n            // Safety: AVM opcodes are constrained by the AVM itself\n            unsafe { avm::storage_write(storage_slot + i as Field, values[i]) };\n        }\n    }\n\n    /// Writes a typed value to public storage.\n    pub fn storage_write<T>(self, storage_slot: Field, value: T)\n    where\n        T: Packable,\n    {\n        self.raw_storage_write(storage_slot, value.pack());\n    }\n}\n\nimpl Empty for PublicContext {\n    fn empty() -> Self {\n        PublicContext::new(|| 0)\n    }\n}\n"
     },
-    "60": {
+    "61": {
       "function_locations": [
         {
           "name": "compute_secret_hash",
@@ -2186,7 +2570,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/hash.nr",
       "source": "//! Aztec hash functions.\n\nuse crate::protocol::{\n    address::{AztecAddress, EthAddress},\n    constants::{\n        DOM_SEP__FUNCTION_ARGS, DOM_SEP__MESSAGE_NULLIFIER, DOM_SEP__PUBLIC_BYTECODE,\n        DOM_SEP__PUBLIC_CALLDATA, DOM_SEP__SECRET_HASH, MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS,\n    },\n    hash::{poseidon2_hash_subarray, poseidon2_hash_with_separator, sha256_to_field},\n    traits::ToField,\n};\n\npub use crate::protocol::hash::compute_siloed_nullifier;\n\npub fn compute_secret_hash(secret: Field) -> Field {\n    poseidon2_hash_with_separator([secret], DOM_SEP__SECRET_HASH)\n}\n\npub fn compute_l1_to_l2_message_hash(\n    sender: EthAddress,\n    chain_id: Field,\n    recipient: AztecAddress,\n    version: Field,\n    content: Field,\n    secret_hash: Field,\n    leaf_index: Field,\n) -> Field {\n    let mut hash_bytes = [0 as u8; 224];\n    let sender_bytes: [u8; 32] = sender.to_field().to_be_bytes();\n    let chain_id_bytes: [u8; 32] = chain_id.to_be_bytes();\n    let recipient_bytes: [u8; 32] = recipient.to_field().to_be_bytes();\n    let version_bytes: [u8; 32] = version.to_be_bytes();\n    let content_bytes: [u8; 32] = content.to_be_bytes();\n    let secret_hash_bytes: [u8; 32] = secret_hash.to_be_bytes();\n    let leaf_index_bytes: [u8; 32] = leaf_index.to_be_bytes();\n\n    for i in 0..32 {\n        hash_bytes[i] = sender_bytes[i];\n        hash_bytes[i + 32] = chain_id_bytes[i];\n        hash_bytes[i + 64] = recipient_bytes[i];\n        hash_bytes[i + 96] = version_bytes[i];\n        hash_bytes[i + 128] = content_bytes[i];\n        hash_bytes[i + 160] = secret_hash_bytes[i];\n        hash_bytes[i + 192] = leaf_index_bytes[i];\n    }\n\n    sha256_to_field(hash_bytes)\n}\n\n// The nullifier of a l1 to l2 message is the hash of the message salted with the secret\npub fn compute_l1_to_l2_message_nullifier(message_hash: Field, secret: Field) -> Field {\n    poseidon2_hash_with_separator([message_hash, secret], DOM_SEP__MESSAGE_NULLIFIER)\n}\n\n// Computes the hash of input arguments or return values for private functions, or for authwit creation.\npub fn hash_args<let N: u32>(args: [Field; N]) -> Field {\n    if args.len() == 0 {\n        0\n    } else {\n        poseidon2_hash_with_separator(args, DOM_SEP__FUNCTION_ARGS)\n    }\n}\n\n// Computes the hash of calldata for public functions.\npub fn hash_calldata_array<let N: u32>(calldata: [Field; N]) -> Field {\n    poseidon2_hash_with_separator(calldata, DOM_SEP__PUBLIC_CALLDATA)\n}\n\n/// Computes the public bytecode commitment for a contract class. The commitment is `hash([(length | separator),\n/// ...bytecode])`.\n///\n/// @param packed_bytecode - The packed bytecode of the contract class. 0th word is the length in bytes.\n/// packed_bytecode is mutable so that we can avoid copying the array to construct one starting with first_field\n/// instead of length. @returns The public bytecode commitment.\npub fn compute_public_bytecode_commitment(\n    mut packed_public_bytecode: [Field; MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS],\n) -> Field {\n    // First field element contains the length of the bytecode\n    let bytecode_length_in_bytes: u32 = packed_public_bytecode[0] as u32;\n    let bytecode_length_in_fields: u32 = (bytecode_length_in_bytes / 31) + (bytecode_length_in_bytes % 31 != 0) as u32;\n    // Don't allow empty public bytecode. AVM doesn't handle execution of contracts that exist with empty bytecode.\n    assert(bytecode_length_in_fields != 0);\n    assert(bytecode_length_in_fields < MAX_PACKED_PUBLIC_BYTECODE_SIZE_IN_FIELDS);\n\n    // Packed_bytecode's 0th entry is the length. Append it to the separator before hashing.\n    let first_field = DOM_SEP__PUBLIC_BYTECODE.to_field() + (packed_public_bytecode[0] as u64 << 32) as Field;\n    packed_public_bytecode[0] = first_field;\n\n    // `fields_to_hash` is the number of fields from the start of `packed_public_bytecode` that should be included in\n    // the hash. Fields after this length are ignored. +1 to account for the separator.\n    let num_fields_to_hash = bytecode_length_in_fields + 1;\n\n    poseidon2_hash_subarray(packed_public_bytecode, num_fields_to_hash)\n}\n"
     },
-    "69": {
+    "70": {
       "function_locations": [
         {
           "name": "compute_nullifier_existence_request",
@@ -2196,7 +2580,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/nullifier/utils.nr",
       "source": "use crate::{context::NullifierExistenceRequest, oracle::nullifiers::is_nullifier_pending};\n\nuse crate::protocol::{address::aztec_address::AztecAddress, hash::compute_siloed_nullifier};\n\n/// Returns the [NullifierExistenceRequest] used to prove a nullifier exists.\npub fn compute_nullifier_existence_request(\n    unsiloed_nullifier: Field,\n    contract_address: AztecAddress,\n) -> NullifierExistenceRequest {\n    let pending_read_request =\n        NullifierExistenceRequest::for_pending(unsiloed_nullifier, contract_address);\n\n    let siloed_nullifier = compute_siloed_nullifier(contract_address, unsiloed_nullifier);\n    let settled_read_request = NullifierExistenceRequest::for_settled(siloed_nullifier);\n\n    // Safety: This is a hint to check whether we are reading a pending or settled nullifier. The chosen read request\n    // will be validated by the kernel. Failure to provide a correct hint will cause the read request validation to\n    // fail.\n    let should_use_pending_read_request =\n        unsafe { is_nullifier_pending(unsiloed_nullifier, contract_address) };\n\n    if should_use_pending_read_request {\n        pending_read_request\n    } else {\n        settled_read_request\n    }\n}\n"
     },
-    "70": {
+    "71": {
       "function_locations": [
         {
           "name": "address",
@@ -2434,7 +2818,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/avm.nr",
       "source": "//! AVM oracles.\n//!\n//! There are only available during public execution. Calling any of them from a private or utility function will\n//! result in runtime errors.\n\nuse crate::protocol::address::{AztecAddress, EthAddress};\n\npub unconstrained fn address() -> AztecAddress {\n    address_opcode()\n}\npub unconstrained fn sender() -> AztecAddress {\n    sender_opcode()\n}\npub unconstrained fn transaction_fee() -> Field {\n    transaction_fee_opcode()\n}\npub unconstrained fn chain_id() -> Field {\n    chain_id_opcode()\n}\npub unconstrained fn version() -> Field {\n    version_opcode()\n}\npub unconstrained fn block_number() -> u32 {\n    block_number_opcode()\n}\npub unconstrained fn timestamp() -> u64 {\n    timestamp_opcode()\n}\npub unconstrained fn min_fee_per_l2_gas() -> u128 {\n    min_fee_per_l2_gas_opcode()\n}\npub unconstrained fn min_fee_per_da_gas() -> u128 {\n    min_fee_per_da_gas_opcode()\n}\npub unconstrained fn l2_gas_left() -> u32 {\n    l2_gas_left_opcode()\n}\npub unconstrained fn da_gas_left() -> u32 {\n    da_gas_left_opcode()\n}\npub unconstrained fn is_static_call() -> bool {\n    is_static_call_opcode()\n}\npub unconstrained fn note_hash_exists(note_hash: Field, leaf_index: u64) -> bool {\n    note_hash_exists_opcode(note_hash, leaf_index)\n}\npub unconstrained fn emit_note_hash(note_hash: Field) {\n    emit_note_hash_opcode(note_hash)\n}\npub unconstrained fn nullifier_exists(siloed_nullifier: Field) -> bool {\n    nullifier_exists_opcode(siloed_nullifier)\n}\npub unconstrained fn emit_nullifier(nullifier: Field) {\n    emit_nullifier_opcode(nullifier)\n}\npub unconstrained fn emit_public_log(message: [Field]) {\n    emit_public_log_opcode(message)\n}\npub unconstrained fn l1_to_l2_msg_exists(msg_hash: Field, msg_leaf_index: u64) -> bool {\n    l1_to_l2_msg_exists_opcode(msg_hash, msg_leaf_index)\n}\npub unconstrained fn send_l2_to_l1_msg(recipient: EthAddress, content: Field) {\n    send_l2_to_l1_msg_opcode(recipient, content)\n}\n\npub unconstrained fn call<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn call_static<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    args: [Field; N],\n) {\n    call_static_opcode(l2_gas_allocation, da_gas_allocation, address, N, args)\n}\n\npub unconstrained fn calldata_copy<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {\n    calldata_copy_opcode(cdoffset, copy_size)\n}\n\n/// `success_copy` is placed immediately after the CALL opcode to get the success value\npub unconstrained fn success_copy() -> bool {\n    success_copy_opcode()\n}\n\npub unconstrained fn returndata_size() -> u32 {\n    returndata_size_opcode()\n}\n\npub unconstrained fn returndata_copy(rdoffset: u32, copy_size: u32) -> [Field] {\n    returndata_copy_opcode(rdoffset, copy_size)\n}\n\n/// The additional prefix is to avoid clashing with the `return` Noir keyword.\npub unconstrained fn avm_return(returndata: [Field]) {\n    return_opcode(returndata)\n}\n\n/// This opcode reverts using the exact data given. In general it should only be used to do rethrows, where the revert\n/// data is the same as the original revert data. For normal reverts, use Noir's `assert` which, on top of reverting,\n/// will also add an error selector to the revert data.\npub unconstrained fn revert(revertdata: [Field]) {\n    revert_opcode(revertdata)\n}\n\npub unconstrained fn storage_read(storage_slot: Field, contract_address: Field) -> Field {\n    storage_read_opcode(storage_slot, contract_address)\n}\n\npub unconstrained fn storage_write(storage_slot: Field, value: Field) {\n    storage_write_opcode(storage_slot, value);\n}\n\n#[oracle(aztec_avm_address)]\nunconstrained fn address_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_sender)]\nunconstrained fn sender_opcode() -> AztecAddress {}\n\n#[oracle(aztec_avm_transactionFee)]\nunconstrained fn transaction_fee_opcode() -> Field {}\n\n#[oracle(aztec_avm_chainId)]\nunconstrained fn chain_id_opcode() -> Field {}\n\n#[oracle(aztec_avm_version)]\nunconstrained fn version_opcode() -> Field {}\n\n#[oracle(aztec_avm_blockNumber)]\nunconstrained fn block_number_opcode() -> u32 {}\n\n#[oracle(aztec_avm_timestamp)]\nunconstrained fn timestamp_opcode() -> u64 {}\n\n#[oracle(aztec_avm_minFeePerL2Gas)]\nunconstrained fn min_fee_per_l2_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_minFeePerDaGas)]\nunconstrained fn min_fee_per_da_gas_opcode() -> u128 {}\n\n#[oracle(aztec_avm_l2GasLeft)]\nunconstrained fn l2_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_daGasLeft)]\nunconstrained fn da_gas_left_opcode() -> u32 {}\n\n#[oracle(aztec_avm_isStaticCall)]\nunconstrained fn is_static_call_opcode() -> bool {}\n\n#[oracle(aztec_avm_noteHashExists)]\nunconstrained fn note_hash_exists_opcode(note_hash: Field, leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_emitNoteHash)]\nunconstrained fn emit_note_hash_opcode(note_hash: Field) {}\n\n#[oracle(aztec_avm_nullifierExists)]\nunconstrained fn nullifier_exists_opcode(siloed_nullifier: Field) -> bool {}\n\n#[oracle(aztec_avm_emitNullifier)]\nunconstrained fn emit_nullifier_opcode(nullifier: Field) {}\n\n#[oracle(aztec_avm_emitPublicLog)]\nunconstrained fn emit_public_log_opcode(message: [Field]) {}\n\n#[oracle(aztec_avm_l1ToL2MsgExists)]\nunconstrained fn l1_to_l2_msg_exists_opcode(msg_hash: Field, msg_leaf_index: u64) -> bool {}\n\n#[oracle(aztec_avm_sendL2ToL1Msg)]\nunconstrained fn send_l2_to_l1_msg_opcode(recipient: EthAddress, content: Field) {}\n\n#[oracle(aztec_avm_calldataCopy)]\nunconstrained fn calldata_copy_opcode<let N: u32>(cdoffset: u32, copy_size: u32) -> [Field; N] {}\n\n#[oracle(aztec_avm_returndataSize)]\nunconstrained fn returndata_size_opcode() -> u32 {}\n\n#[oracle(aztec_avm_returndataCopy)]\nunconstrained fn returndata_copy_opcode(rdoffset: u32, copy_size: u32) -> [Field] {}\n\n#[oracle(aztec_avm_return)]\nunconstrained fn return_opcode(returndata: [Field]) {}\n\n#[oracle(aztec_avm_revert)]\nunconstrained fn revert_opcode(revertdata: [Field]) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_call)]\nunconstrained fn call_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n// While the length parameter might seem unnecessary given that we have N we keep it around because at the AVM bytecode\n// level, we want to support non-comptime-known lengths for such opcodes, even if Noir code will not generally take\n// that route.\n#[oracle(aztec_avm_staticCall)]\nunconstrained fn call_static_opcode<let N: u32>(\n    l2_gas_allocation: u32,\n    da_gas_allocation: u32,\n    address: AztecAddress,\n    length: u32,\n    args: [Field; N],\n) {}\n\n#[oracle(aztec_avm_successCopy)]\nunconstrained fn success_copy_opcode() -> bool {}\n\n#[oracle(aztec_avm_storageRead)]\nunconstrained fn storage_read_opcode(storage_slot: Field, contract_address: Field) -> Field {}\n\n#[oracle(aztec_avm_storageWrite)]\nunconstrained fn storage_write_opcode(storage_slot: Field, value: Field) {}\n"
     },
-    "78": {
+    "79": {
       "function_locations": [
         {
           "name": "notify_created_nullifier",
@@ -2464,7 +2848,7 @@
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/nullifiers.nr",
       "source": "//! Nullifier creation, existence checks, etc.\n\nuse crate::protocol::address::aztec_address::AztecAddress;\n\n/// Notifies the simulator that a nullifier has been created, so that its correct status (pending or settled) can be\n/// determined when reading nullifiers in subsequent private function calls. The first non-revertible nullifier emitted\n/// is also used to compute note nonces.\npub fn notify_created_nullifier(inner_nullifier: Field) {\n    // Safety: This oracle call returns nothing: we only call it for its side effects. It is therefore always safe to\n    // call.\n    unsafe { notify_created_nullifier_oracle(inner_nullifier) };\n}\n\n#[oracle(aztec_prv_notifyCreatedNullifier)]\nunconstrained fn notify_created_nullifier_oracle(_inner_nullifier: Field) {}\n\n/// Returns true if the nullifier has been emitted in the same transaction, i.e. if [notify_created_nullifier] has been\n/// called for this inner nullifier from the contract with the specified address.\n///\n/// Note that despite sharing pending transaction information with the app, this is not a privacy leak: anyone in the\n/// network can always determine in which transaction a inner nullifier was emitted by a given contract by simply\n/// inspecting transaction effects. What _would_ constitute a leak would be to share the list of inner pending\n/// nullifiers, as that would reveal their preimages.\npub unconstrained fn is_nullifier_pending(\n    inner_nullifier: Field,\n    contract_address: AztecAddress,\n) -> bool {\n    is_nullifier_pending_oracle(inner_nullifier, contract_address)\n}\n\n#[oracle(aztec_prv_isNullifierPending)]\nunconstrained fn is_nullifier_pending_oracle(\n    _inner_nullifier: Field,\n    _contract_address: AztecAddress,\n) -> bool {}\n\n/// Returns true if the nullifier exists. Note that a `true` value can be constrained by proving existence of the\n/// nullifier, but a `false` value should not be relied upon since other transactions may emit this nullifier before\n/// the current transaction is included in a block. While this might seem of little use at first, certain design\n/// patterns benefit from this abstraction (see e.g. `PrivateMutable`).\npub unconstrained fn check_nullifier_exists(inner_nullifier: Field) -> bool {\n    check_nullifier_exists_oracle(inner_nullifier)\n}\n\n// TODO(F-498): review naming consistency\n#[oracle(aztec_utl_doesNullifierExist)]\nunconstrained fn check_nullifier_exists_oracle(_inner_nullifier: Field) -> bool {}\n"
     },
-    "82": {
+    "83": {
       "function_locations": [
         {
           "name": "assert_compatible_oracle_version",
@@ -2488,7 +2872,7 @@
         }
       ],
       "path": "/home/aztec-dev/aztec-packages/noir-projects/noir-contracts/contracts/protocol/aztec_sublib/src/oracle/version.nr",
-      "source": "/// The oracle version constants are used to check that the oracle interface is in sync between PXE and Aztec.nr.\n/// We version the oracle interface as `major.minor` where:\n///   - `major` = backward-breaking changes (must match exactly between PXE and Aztec.nr)\n///   - `minor` = oracle additions (non-breaking; PXE minor >= contract minor)\n///\n/// The TypeScript counterparts are in `oracle_version.ts`.\n///\n/// @dev Whenever a contract function or Noir test is run, the `aztec_misc_assertCompatibleOracleVersion` oracle is\n/// called. If the major version is incompatible, an error is thrown immediately. The minor version is recorded by\n/// the PXE and used to provide helpful error messages if a contract calls an oracle that doesn't exist. We don't throw\n/// immediately if AZTEC_NR_MINOR > PXE_MINOR because if a contract is updated to use a newer Aztec.nr dependency\n/// without actually using any of the new oracles then there is no reason to throw.\npub global ORACLE_VERSION_MAJOR: Field = 29;\npub global ORACLE_VERSION_MINOR: Field = 0;\n\n/// Asserts that the version of the oracle is compatible with the version expected by the contract.\npub fn assert_compatible_oracle_version() {\n    // Safety: This oracle call returns nothing: we only call it to check Aztec.nr and Oracle interface versions are\n    // compatible. It is therefore always safe to call.\n    unsafe {\n        assert_compatible_oracle_version_wrapper();\n    }\n}\n\nunconstrained fn assert_compatible_oracle_version_wrapper() {\n    assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n}\n\n#[oracle(aztec_misc_assertCompatibleOracleVersion)]\nunconstrained fn assert_compatible_oracle_version_oracle(major: Field, minor: Field) {}\n\nmod test {\n    use super::{\n        assert_compatible_oracle_version_oracle, ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR,\n    };\n\n    #[test]\n    unconstrained fn compatible_oracle_version() {\n        assert_compatible_oracle_version_oracle(ORACLE_VERSION_MAJOR, ORACLE_VERSION_MINOR);\n    }\n\n    #[test(should_fail_with = \"Incompatible aztec cli version:\")]\n    unconstrained fn incompatible_oracle_version_major() {\n        let arbitrary_incorrect_major = 318183437;\n        assert_compatible_oracle_version_oracle(arbitrary_incorrect_major, ORACLE_VERSION_MINOR);\n    }\n}\n"
+      "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": {
       "function_locations": [
@@ -2636,12 +3020,12 @@
           "visibility": "public"
         }
       },
-      "bytecode": "JwACBAEoAAABBIBEJwAABEQnAgIEACcCAwQAHwoAAgADAEMlAAAAPC0CAkMnAgMEQycCBAQBOw4ABAADHgIAAwknAgQBASQCAAMAAABTJQAAAngeAgADASkCAAQA71JTTScCBQABKwIABgAAAAAAAAAAAwAAAAAAAAAALQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0OBAkAIgkCCS0OBQkAIgkCCS0OAwkAIgkCCS0OBgktCAEDJwIEBAUACAEEAScDAwQBACIHAgQAIgMCBT8PAAQABScCBAQBACoDBAUtCwUFJwIDAAAKKgUDBCcCAwEACioEAwYkAgAGAAABCCUAAAKKHgIAAwYeAgAEAC8qAAUABAAGHAoGBQQcCgUEAAIqBgQFLAIABAAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBQQGHAoGBwQcCgcFAAIqBgUHBCoHBAYcCgYIAhwKCAcAHAoHCAIcCggJARwKCQcCJwIIAgAKKgcICRYKCQccCgcKAAIqBgoLLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCwYKHAoKDAQcCgwLAAIqCgsMBCoMBAocCgoMAhwKDAQAHAoEDAIcCgwNARwKDQQCCioECAwWCgwEHAoECAACKgoIDQQqDQYIHAoICgQcCgoGABwKBggFHAoMBgUcCgQKBQQqCggEHAoLCAUcCgkKBRwKBwkFBCoJCAccCgUIBQwqAwgFKQIAAwUAAVGAJAIABQAAAmgjAAACWQQqCgMEACoHBAIjAAACdwQqBgMFACoEBQIjAAACdyYqAQABBU/fSorXz/DTPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
+      "bytecode": "JwACBAEoAAABBIBEJwAABEQnAgIEACcCAwQAHwoAAgADAEMlAAAAPC0CAkMnAgMEQycCBAQBOw4ABAADHgIAAwknAgQBASQCAAMAAABTJQAAAngeAgADASkCAAQA71JTTScCBQABKwIABgAAAAAAAAAAAwAAAAAAAAAALQgBBycCCAQFAAgBCAEnAwcEAQAiBwIILQoICS0OBAkAIgkCCS0OBQkAIgkCCS0OAwkAIgkCCS0OBgktCAEDJwIEBAUACAEEAScDAwQBACIHAgQAIgMCBT8PAAQABScCBAQBACoDBAUtCwUFJwIDAAAKKgUDBCcCAwEACioEAwYkAgAGAAABCCUAAAKKHgIAAwYeAgAEAC8qAAUABAAGHAoGBQQcCgUEAAIqBgQFLAIABAAtXgmLgro3tDuZoTFhGP0g1C9RZsnp8T+16mWpbR4KbQQqBQQGHAoGBwQcCgcFAAIqBgUHBCoHBAYcCgYIAhwKCAcAHAoHCAIcCggJARwKCQcCJwIIAgAKKgcICRYKCQccCgcKAAIqBgoLLAIABgAwM+okblBuiY6X9XDK/9cEywu0YDE/tyCynhOeXBAAAQQqCwYKHAoKDAQcCgwLAAIqCgsMBCoMBAocCgoMAhwKDAQAHAoEDAIcCgwNARwKDQQCCioECAwWCgwEHAoECAACKgoIDQQqDQYIHAoICgQcCgoGABwKBggFHAoMBgUcCgQKBQQqCggEHAoLCAUcCgkKBRwKBwkFBCoJCAccCgUIBQwqAwgFKQIAAwUAAVGAJAIABQAAAlkjAAACaAQqBgMFACoEBQIjAAACdwQqCgMEACoHBAIjAAACdyYqAQABBU/fSorXz/DTPAQCASYqAQABBbq7IdeCMxhkPAQCASY=",
       "custom_attributes": [
         "abi_public",
         "abi_view"
       ],
-      "debug_symbols": "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": "rVhbbuM4ELyLvv3BfvGRqwwGgZM4AwOGE3iSBRaB777dMZuyFyA34eyPVS5ZpWKz2JT1sTztHt5/3e+Pzy+/l7sfH8vDaX847H/dH14et2/7l6OyH0uwj6iftFmiLHe8WVK4HPLnIdNyF/Wg30B/U9LlCAErQHLgp8hPkTPsDDsj4EAqMBMXwA5KBclvkaoLyCYoBmIFBRxUBgM4cAacAbOho0JEB86Q/SYbiBWwMcVArECckVKBeUYyoAwak5QhUGBWyU7lVEExhg0Yo36I2IFeTmqDmB0YkxSIMdmAMXoLsptegDN2Uw4GSgXZGDBQKijOFJtg3CwctLxMBoxRY8xSgVgWxIBUYNPE0YAxaow/85INSAXZmWyMGuMSHCgjakxCcKB+BAyoQ1E/AsaQAWPUhiA7MEZtiFXsApxhZ6xiog7FKnYBzkRnrGKi5sUqJuV83iy+LO7fTrudrYqrdaKr53V72h3flrvj++GwWf7aHt4/f/T7dXv8PL5tT3pWB7Q7PulRBZ/3h52h82a9OvQvBY1DrJcrLrlJCN5oQF+jRIAqUSLhqpBvFHDgIuRmAkJpCgm+MY5YXIJCDL1xjDQIsNkgoNLTkL4GsbvQhTIzDgolrR5Qeh7SqBa2ZnxKV4UsNwq5r4DZI0VXiUC4tVAGkaDgFgrxGglI5TZVg1KUYO3hohFK6GvAaDpcgvLVQOhfCoNoatf2TCBkntNAchuIceCDByMpKVcNDiBX1fiyDZWANq2pdG2MogXlepX1ogUDiYToEkk3t1WCvyOBLkEAPYmvLzPptj0ciURmL6jiSD0jOEho1r2tamROsds8B/Ma25wkTUOn5/zHQJKsAympO5BBQPXpKHhCFVO/GjLaCJBaCw4oqVuPOGgcZZ3bEIC7GoOIRX38qxoRct/GqIm2BYuluxWMxyG4jgNzzwQNppZE2pqPAbs2xhMbm4+sjb03sTRqgQWlVYPyVfuCb2i0pUI6r5Ma0jbo2zb6dQ0tQatpiDCp0VacdjCa1eCmgWlOAyQ1jRhnNWLTSPA/aMz6KE0DcdZHCX+ukVvGkHhOA2PLGM7WFHPLGMGsj9wyRji3bonWjNFsxmjNB83W40Zj1seaMcYwqxH+XGPNGNNk/+C1F3IscxqJfW/QkuKcRr76uzHZ1/V/Slofj/u98OuPQdJ/sJTRrh9Ce9YPfG1ENX7q1+3j/nTzNuxsYqf99uGwq1+f34+PV2ff/n71M/427fX08rh7ej/tTGl9pWavmn6A/iHSLeXn2e73Dw==",
       "is_unconstrained": true,
       "name": "get_update_delay"
     },
@@ -2657,6 +3041,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 +3089,11 @@
         ],
         "return_type": null
       },
-      "bytecode": "JwACBAEoAAABBIBPJwAABE8lAAAAQScCAwQBJwIEBAAfCgADAAQATi0ITgIlAAAAxycCAgRPJwIDBAA7DgADAAIpAABDAPqRAsspAABEAMB7XhkpAABFAAVVe/onAEYAASwAAEcALc/6U80Ocdp7SiJnezNCv8O5BD9Qgb6lg2itAI6qbzcoAABIBQJYLAAASQAwZE5y4TGgKbhQRbaBgVhdKDPoSHm5cJFD4fWT8AAAACcASgQDJwBLAQEnAEwEAScATQACJgoiAkMDJwIFBAAnAgcEAwAqBQcGLQgBBAAIAQYBJwMEBAEAIgQCBi0OBQYAIgYCBi0OBQYnAgYEAwAqBAYFJwIFBAAnAgYBACcCBwAAKQIACAADbVJ/KwIACQAAAAAAAAAAAwAAAAAAAAAAKQIACgDvUlNNJwILBAIpAgAMBQABUYAnAg0AAyQCAAMAAAFbIwAABdMtCAEOJwIPBAIACAEPAScDDgQBACIOAg8fMABMAEwADwAiDkwPLQsPDx4CAA4BCiIOSRAWChARHAoREgAEKhIOEQoqEAYOJAIADgAAAbInAhIEADwGEgEeAgAOAC0IARAnAhIEBQAIARIBJwMQBAEAIhACEi0KEhMtDggTACITAhMtDg4TACITAhMtDhETACITAhMtDgkTLQgBDicCEgQFAAgBEgEnAw4EAQAiEAISACIOAhM/DwASABMAIg5MEC0LEBAzCgAQAA4kAgAOAAACMSUAAAz+LQgBDicCEAQFAAgBEAEnAw4EAQAiDgIQLQoQEi0OCBIAIhICEi0MRhIAIhICEi0ODxIAIhICEi0OCRItCAEQJwISBAUACAESAScDEAQBACIOAhIAIhACEz8PABIAEwAiEEwOLQsODjMKAA4AECQCABAAAAKrJQAADRAtCAEOJwIQBAUACAEQAScDDgQBACIOAhAtChASLQ4KEgAiEgISLQxGEgAiEgISLQ4REgAiEgISLQ4JEi0IARAnAhIEBQAIARIBJwMQBAEAIg4CEgAiEAITPw8AEgATACIQTA4tCw4OCioOBxAKKhAGEiQCABIAAAMpJQAADSIeAgAQAC8qAA4AEAASACIORhAeAgATAC8qABAAEwAUACIOTRMeAgAVAC8qABMAFQAWHAoSFwQcChcVABwKFRIFHgIAFQAvKgAOABUAFycCHAQdLQgAHS0KFx8ACAAcACUAAA00LQIAAC0KHxUtCiAYLQohGS0KIhotCiMbHgIAFwYMKhcbHCQCABwAAAPeIwAAA7wWChkcHAoZHQUcChweBQQqHRocBCoeDB0AKhwdAyMAAAQAFgoVHBwKFR0FHAocHgUEKh0YHAQqHgwdACocHQMjAAAEAAAqFwMcDioXHB0kAgAdAAAEFyUAAA5fDCoXEgMWCgMSHAoDFwAcChIDAAQqFxQSBCoDFhQAKhIUAycCFAQdLQgAHS0KAx8tCg8gLQocIS0KFSItChgjLQoZJC0KGiUtChsmAAgAFAAlAAAOcS0CAAAtCh8SLQsSFAAiFAIULQ4UEgAiEkwULQsUFAAqEgsVLQsVFQAiEkoWLQsWFi0IARInAhcEBQAIARcBJwMSBAEAIhICFy0KFxgtDhQYACIYAhgtDhUYACIYAhgtDhYYACIYAhgtDgkYLQgBFycCGAQFAAgBGAEnAxcEAQAiEgIYACIXAhk/DwAYABkAIhdMEi0LEhIwCgAUAA4wCgAVABAwCgAWABMAKg4NEDAKABIAEBwKHA4AJwISBAUnAhQEAwAqEhQTLQgBEAAIARMBJwMQBAEAIhACEy0OEhMAIhMCEy0OEhMnAhMEAwAqEBMSLQoSEy0MRxMAIhMCEy0OERMAIhMCEy0OAxMAIhMCEy0ODxMAIhMCEy0ODhMnAgMEBQAiEAIPLQsPDycCEQQDACoQEQ43DgAPAA4tCwQDACIDAgMtDgMEACIEAg4tCw4OJwIPBAMAKgQPAzsOAA4AAyMAAAXTCiICRAMkAgADAAAF5SMAAAmbLQgBDicCDwQCAAgBDwEnAw4EAQAiDgIPHzAATABMAA8AIg5MDy0LDw8cCg8QBRwKEA4AHAoODwUeAgAOAQoiDkkQFgoQERwKERIABCoSDhEKKhAGDiQCAA4AAAZLJwISBAA8BhIBHgIADgAtCAEQJwISBAUACAESAScDEAQBACIQAhItChITLQ4IEwAiEwITLQ4OEwAiEwITLQ4REwAiEwITLQ4JEy0IAQgnAg4EBQAIAQ4BJwMIBAEAIhACDgAiCAISPw8ADgASACIITA4tCw4OMwoADgAIJAIACAAABsolAAAM/gwiD0gICioIBg4kAgAOAAAG4SUAAA/ALQgBCCcCDgQFAAgBDgEnAwgEAQAiCAIOLQoOEC0OChAAIhACEC0MRhAAIhACEC0OERAAIhACEC0OCRAtCAEOJwIQBAUACAEQAScDDgQBACIIAhAAIg4CET8PABAAEQAiDkwILQsICAoqCAcOCioOBhAkAgAQAAAHXyUAAA0iHgIADgAvKgAIAA4AECcCFQQWLQgAFi0KEBgACAAVACUAAA00LQIAAC0KGA4tChkRLQoaEi0KGxMtChwUHgIAEAYMKhAUFSQCABUAAAfUIwAAB7IWChIOHAoSEQUcCg4SBQQqERMOBCoSDBEAKg4RAyMAAAf2FgoOEhwKDhMFHAoSDgUEKhMREgQqDgwRACoSEQMjAAAH9gwqAw8RJAIAEQAACCQjAAAICAIqAw8ODioPAxEkAgARAAAIHyUAAA/SIwAACDInAhEFAC0KEQ4jAAAIMgAqEA4RDioQERIkAgASAAAISSUAAA5fHgIADgAvKgAIAA4AEAAiCEYOHgIAEgAvKgAOABIAEwAiCE0SHgIAFAAvKgASABQAFRwKEBYEHAoWFAAcChQQBScCFgQXLQgAFy0KExktChUaLQoQGy0ISxwtCgMdLQhLHi0KDx8tChEgAAgAFgAlAAAOcS0CAAAtChkULQsUAwAiAwIDLQ4DFAAiFEwDLQsDAwAqFAsPLQsPDwAiFEoLLQsLCy0IARAnAhEEBQAIAREBJwMQBAEAIhACES0KERMtDgMTACITAhMtDg8TACITAhMtDgsTACITAhMtDgkTLQgBEScCEwQFAAgBEwEnAxEEAQAiEAITACIRAhQ/DwATABQAIhFMEC0LEBAwCgADAAgwCgAPAA4wCgALABIAKggNAzAKABAAAy0LBAMAIgMCAy0OAwQAIgQCCC0LCAgnAgsEAwAqBAsDOw4ACAADIwAACZsKIgJFAyQCAAMAAAmtIwAACz0eAgAECSQCAAQAAAm/JQAAD+QeAgAEAS0IAQUnAggEBQAIAQgBJwMFBAEAIgUCCC0KCAstDgoLACILAgstDEYLACILAgstDgQLACILAgstDgkLLQgBBCcCCAQFAAgBCAEnAwQEAQAiBQIIACIEAgk/DwAIAAkAIgRMBS0LBQUKKgUHBAoqBAYHJAIABwAACkIlAAANIh4CAAQGHgIABwAvKgAFAAcACCcCDQQOLQgADi0KCBAACAANACUAAA00LQIAAC0KEAUtChEHLQoSCS0KEwotChQLDCoECwgkAgAIAAAKtyMAAAqVFgoJBBwKCQUFHAoEBwUEKgUKBAQqBwwFACoEBQMjAAAK2RYKBQQcCgUIBRwKBAUFBCoIBwQEKgUMBwAqBAcDIwAACtkcCgMEACcCBQQBJwIIBAMAKgUIBy0IAQMACAEHAScDAwQBACIDAgctDgUHACIHAgctDgUHJwIHBAMAKgMHBS0KBQctDgQHACIDAgUtCwUFJwIHBAMAKgMHBDsOAAUABCMAAAs9JwIDAlUnAgQCbicCBQJrJwIHAm8nAggCdycCCQIgJwIKAnMnAgsCZScCDAJsJwINAmMnAg4CdCcCDwJyJwIQAnsnAhECfS0IARInAhMEHAAIARMBJwMSBAEAIhICEy0KExQtDgMUACIUAhQtDgQUACIUAhQtDgUUACIUAhQtDgQUACIUAhQtDgcUACIUAhQtDggUACIUAhQtDgQUACIUAhQtDgkUACIUAhQtDgoUACIUAhQtDgsUACIUAhQtDgwUACIUAhQtDgsUACIUAhQtDg0UACIUAhQtDg4UACIUAhQtDgcUACIUAhQtDg8UACIUAhQtDgkUACIUAhQtDhAUACIUAhQtDgoUACIUAhQtDgsUACIUAhQtDgwUACIUAhQtDgsUACIUAhQtDg0UACIUAhQtDg4UACIUAhQtDgcUACIUAhQtDg8UACIUAhQtDhEUCiIGSwMkAgADAAAM/icCBAQeLQgBBScCBwQeAAgBBwEtCgUHKgMABwWbW7/3Slv/GQAiBwIHACISAggnAgkEGy0CCAMtAgcELQIJBSUAAA/2JwIIBBsAKgcIBy0MRgcAIgcCBy0OAgcAIgcCBzwOBAUqAQABBdUSfSnC0ujtPAQCASYqAQABBa6Sj2upjpKMPAQCASYqAQABBbq7IdeCMxhkPAQCASYcCgIEBBwKBAMAAioCAwQsAgACAC1eCYuCuje0O5mhMWEY/SDUL1FmyenxP7XqZaltHgptBCoEAgMcCgMFBBwKBQQAAioDBAUEKgUCAxwKAwYCHAoGBQAcCgUGAhwKBgcBHAoHBQInAgYCAAoqBQYHFgoHBRwKBQcAAioDBwgsAgADADAz6iRuUG6Jjpf1cMr/1wTLC7RgMT+3ILKeE55cEAABBCoIAwccCgcJBBwKCQgAAioHCAkEKgkCBxwKBwkCHAoJAgAcCgIJAhwKCQoBHAoKAgIKKgIGCRYKCQIcCgIGAAIqBwYJBCoJAwYcCgYHBBwKBwMAHAoDBgUcCgIDBQQqAwYHHAoIAwUcCgUGBQQqBgMIHAoEAwUtCgUELQoIBS0KAwYtCgcDJioBAAEF0Afr9MvGZ5A8BAIBJhwKBAoAHAoJBAAnAgkAICcCDAQNLQgADS0ITQ8tCgkQAAgADAAlAAAQKC0CAAAtCg8LBCoECwkAKgoJBBwKBwkAJwIHAEAnAgsEDC0IAAwtCE0OLQoHDwAIAAsAJQAAECgtAgAALQoOCgQqCQoHACoEBwkcCggEACcCBwBIJwIKBAstCAALLQhNDS0KBw4ACAAKACUAABAoLQIAAC0KDQgEKgQIBwAqCQcEHAoFBwAnAgUAaCcCCQQKLQgACi0ITQwtCgUNAAgACQAlAAAQKC0CAAAtCgwIBCoHCAUAKgQFBxwKBgQAJwIFAHAnAggECS0IAAktCE0LLQoFDAAIAAgAJQAAECgtAgAALQoLBgQqBAYFACoHBQQtCAEFJwIGBAQACAEGAScDBQQBACIFAgYtCgYHLQ4EBwAiBwIHLQ4CBwAiBwIHLQ4DBy0KBQImKgEAAQVebT8u3M2HCTwEAgEmKgEAAQUbvGXQP9zq3DwEAgEmKgEAAQVP30qK18/w0zwEAgEmAAADBQctAAMILQAECSMAABAaLQEIBi0EBgkAAAgCCAAACQIJDAAIBwokAAAKAAAQCCYnAgcEAicCCAEBLQgBBicCCQQhAAgBCQEnAwYEAQAiBgIJJwIKBCBDA6oAAwAHAAoACAAJLQIJAy0CCgQlAAAQ/ycCAwQhJwIHBCAtCEwELQhGBSMAABCADCoEAwgkAgAIAAAQlyMAABCSLQoFAiYEKgUFCAIqBwQJDioEBwokAgAKAAAQsyUAAA/SDCoJBwokAgAKAAAQxSUAABE6ACIGAgsAKgsJCi0LCgocCgoJAAQqCAIKBCoJCgsCKEYJCgQqCggJACoLCQUAIgRMCC0KCAQjAAAQgC0AAwcAAAMECAIACAIIIwAAESwtAQcFLQEIBi0EBgctBAUIAAAHAgcCAAgCCAwABwgJJAAACQAAERImKgEAAQXkCFBFArWMHzwEAgEm",
+      "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 +3569,12 @@
                     "sign": "unsigned",
                     "width": 32
                   }
+                },
+                {
+                  "name": "tx_request_salt",
+                  "type": {
+                    "kind": "field"
+                  }
                 }
               ],
               "kind": "struct",
@@ -4578,6 +4972,12 @@
                   "kind": "struct",
                   "path": "aztec::protocol_types::utils::arrays::claimed_length_array::ClaimedLengthArray"
                 }
+              },
+              {
+                "name": "tx_request_salt",
+                "type": {
+                  "kind": "field"
+                }
               }
             ],
             "kind": "struct",
@@ -4586,18 +4986,22 @@
           "visibility": "databus"
         }
       },
-      "bytecode": "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",
+      "bytecode": "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",
       "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 +5040,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 +5100,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.25+75061fab15986eedee4e7d9104ff87dd9fa4ca10",
   "outputs": {
     "globals": {},
     "structs": {
@@ -5128,5 +5536,5 @@
     }
   },
   "transpiled": true,
-  "aztec_version": "0.0.1-commit.2f68f620"
+  "aztec_version": "0.0.1-commit.321f6a9"
 }