@crisp-e3/sdk 0.25.0 → 0.27.0-insecure.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (13) hide show
  1. package/README.md +2 -2
  2. package/dist/{circuits-BTUteTjK.d.ts → circuits-DAHZRhC4.d.ts} +3 -3
  3. package/dist/index.d.ts +1 -1
  4. package/dist/index.js +4 -4
  5. package/dist/index.js.map +1 -1
  6. package/dist/presets/{insecure-512.d.ts → insecure-64.d.ts} +2 -2
  7. package/dist/presets/insecure-64.js +26 -0
  8. package/dist/presets/secure-8192.d.ts +1 -8
  9. package/dist/presets/secure-8192.js +6 -20
  10. package/dist/workers/generateCircuitInputs.worker.js.map +1 -1
  11. package/package.json +10 -10
  12. package/dist/.tsbuildinfo +0 -1
  13. package/dist/presets/insecure-512.js +0 -26
package/dist/presets/insecure-64.js ADDED
@@ -0,0 +1,26 @@
1
+ // ../../circuits/dist/insecure-64/crisp.json
2
+ var crisp_default = { noir_version: "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905", hash: "11664074917898240202", abi: { parameters: [{ name: "prev_ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "prev_ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "prev_ct_commitment", type: { kind: "field" }, visibility: "public" }, { name: "sum_ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_r0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_r1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "k1", type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "public_key_x", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "public_key_y", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "signature", type: { kind: "array", length: 64, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "digest_hi", type: { kind: "field" }, visibility: "public" }, { name: "digest_lo", type: { kind: "field" }, visibility: "public" }, { name: "slot_address", type: { kind: "field" }, visibility: "public" }, { name: "merkle_root", type: { kind: "field" }, visibility: "public" }, { name: "balance", type: { kind: "field" }, visibility: "private" }, { name: "merkle_proof_length", type: { kind: "integer", sign: "unsigned", width: 32 }, visibility: "private" }, { name: "merkle_proof_indices", type: { kind: "array", length: 20, type: { kind: "boolean" } }, visibility: "private" }, { name: "merkle_proof_siblings", type: { kind: "array", length: 20, type: { kind: "field" } }, visibility: "private" }, { name: "is_first_vote", type: { kind: "boolean" }, visibility: "public" }, { name: "is_mask_vote", type: { kind: "boolean" }, visibility: "private" }, { name: "num_options", type: { kind: "integer", sign: "unsigned", width: 32 }, visibility: "public" }], return_type: { abi_type: { kind: "tuple", fields: [{ kind: "field" }, { kind: "field" }, { kind: "field" }] }, visibility: "public" }, error_types: { "819864067177566446": { error_kind: "string", string: "Field failed to decompose into specified 8 limbs" }, "6648636420357809117": { error_kind: "string", string: "the addend does not open the parent commitment" }, "12469291177396340830": { error_kind: "string", string: "call to assert_max_bit_size" }, "14401109495927734611": { error_kind: "string", string: "Field failed to decompose into specified 16 limbs" }, "14990209321349310352": { error_kind: "string", string: "attempt to add with overflow" }, "17263889889423824360": { error_kind: "string", string: "the published ciphertext is not the ballot added to the addend" } } }, bytecode: "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", debug_symbols: "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", file_map: { "12": { source: "// docs:start:ecdsa_secp256k1\n/// Verifies a ECDSA signature over the secp256k1 curve.\n/// - inputs:\n/// - x coordinate of public key as 32 bytes\n/// - y coordinate of public key as 32 bytes\n/// - the signature, as a 64 bytes array\n/// The signature internally will be represented as `(r, s)`,\n/// where `r` and `s` are fixed-sized big endian scalar values.\n/// As the `secp256k1` has a 256-bit modulus, we have a 64 byte signature\n/// while `r` and `s` will both be 32 bytes.\n/// We expect `s` to be normalized. This means given the curve's order,\n/// `s` should be less than or equal to `order / 2`.\n/// This is done to prevent malleability.\n/// For more context regarding malleability you can reference BIP 0062.\n/// - the hash of the message, as a vector of bytes\n/// - output: false for failure and true for success\npub fn verify_signature(\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n message_hash: [u8; 32],\n) -> bool\n// docs:end:ecdsa_secp256k1\n{\n _verify_signature(public_key_x, public_key_y, signature, message_hash, true)\n}\n\n#[foreign(ecdsa_secp256k1)]\nfn _verify_signature(\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n message_hash: [u8; 32],\n predicate: bool,\n) -> bool {}\n\nmod tests {\n #[test]\n fn verify() {\n let mut hashed_message: [u8; 32] = [\n 0x3a, 0x73, 0xf4, 0x12, 0x3a, 0x5c, 0xd2, 0x12, 0x1f, 0x21, 0xcd, 0x7e, 0x8d, 0x35,\n 0x88, 0x35, 0x47, 0x69, 0x49, 0xd0, 0x35, 0xd9, 0xc2, 0xda, 0x68, 0x06, 0xb4, 0x63,\n 0x3a, 0xc8, 0xc1, 0xe2,\n ];\n let pub_key_x: [u8; 32] = [\n 0xa0, 0x43, 0x4d, 0x9e, 0x47, 0xf3, 0xc8, 0x62, 0x35, 0x47, 0x7c, 0x7b, 0x1a, 0xe6,\n 0xae, 0x5d, 0x34, 0x42, 0xd4, 0x9b, 0x19, 0x43, 0xc2, 0xb7, 0x52, 0xa6, 0x8e, 0x2a,\n 0x47, 0xe2, 0x47, 0xc7,\n ];\n let pub_key_y: [u8; 32] = [\n 0x89, 0x3a, 0xba, 0x42, 0x54, 0x19, 0xbc, 0x27, 0xa3, 0xb6, 0xc7, 0xe6, 0x93, 0xa2,\n 0x4c, 0x69, 0x6f, 0x79, 0x4c, 0x2e, 0xd8, 0x77, 0xa1, 0x59, 0x3c, 0xbe, 0xe5, 0x3b,\n 0x03, 0x73, 0x68, 0xd7,\n ];\n let signature: [u8; 64] = [\n 0xe5, 0x08, 0x1c, 0x80, 0xab, 0x42, 0x7d, 0xc3, 0x70, 0x34, 0x6f, 0x4a, 0x0e, 0x31,\n 0xaa, 0x2b, 0xad, 0x8d, 0x97, 0x98, 0xc3, 0x80, 0x61, 0xdb, 0x9a, 0xe5, 0x5a, 0x4e,\n 0x8d, 0xf4, 0x54, 0xfd, 0x28, 0x11, 0x98, 0x94, 0x34, 0x4e, 0x71, 0xb7, 0x87, 0x70,\n 0xcc, 0x93, 0x1d, 0x61, 0xf4, 0x80, 0xec, 0xbb, 0x0b, 0x89, 0xd6, 0xeb, 0x69, 0x69,\n 0x01, 0x61, 0xe4, 0x9a, 0x71, 0x5f, 0xcd, 0x55,\n ];\n let valid_signature =\n super::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);\n assert(valid_signature);\n\n hashed_message[0] = 0;\n let valid_signature =\n super::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);\n assert(!valid_signature);\n }\n}\n", path: "std/ecdsa_secp256k1.nr", function_locations: [{ start: 1057, name: "verify_signature" }, { start: 1333, name: "_verify_signature" }, { start: 1377, name: "tests::verify" }] }, "16": { 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', path: "std/field/mod.nr", function_locations: [{ start: 380, name: "Field::assert_max_bit_size" }, { start: 1196, name: "Field::to_le_bits" }, { start: 2387, name: "Field::to_be_bits" }, { start: 3562, name: "Field::to_le_bytes" }, { start: 5033, name: "Field::to_be_bytes" }, { start: 5904, name: "Field::to_le_radix" }, { start: 6362, name: "Field::to_be_radix" }, { start: 7053, name: "Field::pow_32" }, { start: 7455, name: "Field::sgn0" }, { start: 7538, name: "Field::lt" }, { start: 8073, name: "Field::from_le_bytes" }, { start: 8820, name: "Field::from_be_bytes" }, { start: 9611, name: "Field::from_le_bytes_checked" }, { start: 10620, name: "Field::from_be_bytes_checked" }, { start: 11202, name: "__assert_max_bit_size" }, { start: 11330, name: "__to_le_radix" }, { start: 11458, name: "__to_be_radix" }, { start: 12179, name: "__to_le_bits" }, { start: 12897, name: "__to_be_bits" }, { start: 12972, name: "modulus_num_bits" }, { start: 13048, name: "modulus_be_bits" }, { start: 13124, name: "modulus_le_bits" }, { start: 13200, name: "modulus_be_bytes" }, { start: 13276, name: "modulus_le_bytes" }, { start: 13437, name: "__field_less_than" }, { start: 13513, name: "field_less_than" }, { start: 13589, name: "lt_fallback" }, { start: 14551, name: "tests::test_to_be_bits" }, { start: 14824, name: "tests::test_to_le_bits" }, { start: 15099, name: "tests::test_to_be_bytes" }, { start: 15405, name: "tests::test_to_le_bytes" }, { start: 15711, name: "tests::test_to_be_radix" }, { start: 16293, name: "tests::test_to_le_radix" }, { start: 16893, name: "tests::test_to_le_radix_1" }, { start: 17346, name: "tests::test_to_le_radix_brillig_1" }, { start: 17700, name: "tests::test_to_le_radix_3" }, { start: 18011, name: "tests::test_to_le_radix_brillig_3" }, { start: 18439, name: "tests::test_to_le_radix_512" }, { start: 18848, name: "tests::not_enough_limbs_brillig" }, { start: 19044, name: "tests::not_enough_limbs" }, { start: 19274, name: "tests::non_zero_field_to_le_bytes_zero_limbs" }, { start: 19469, name: "tests::non_zero_field_to_be_bytes_zero_limbs" }, { start: 19600, name: "tests::zero_field_to_bytes_zero_limbs_unconstrained" }, { start: 19915, name: "tests::zero_field_to_bytes_zero_limbs_constrained" }, { start: 20227, name: "tests::zero_field_to_bytes_zero_limbs_comptime" }, { start: 20558, name: "tests::test_field_less_than" }, { start: 20813, name: "tests::test_large_field_values_unconstrained" }, { start: 21266, name: "tests::test_large_field_values" }, { start: 21713, name: "tests::test_decomposition_edge_cases" }, { start: 22303, name: "tests::test_pow_32" }, { start: 22632, name: "tests::test_sgn0" }, { start: 23054, name: "tests::test_bit_decomposition_overflow" }, { start: 23336, name: "tests::test_byte_decomposition_overflow" }, { start: 23553, name: "tests::test_to_from_be_bytes_bn254_edge_cases" }, { start: 25504, name: "tests::test_to_from_le_bytes_bn254_edge_cases" }, { start: 27439, name: "tests::test_from_le_bytes_checked_accepts_modulus_minus_one" }, { start: 27918, name: "tests::test_from_le_bytes_checked_rejects_modulus" }, { start: 28303, name: "tests::test_from_le_bytes_checked_rejects_modulus_plus_one" }, { start: 28758, name: "tests::test_from_be_bytes_checked_accepts_modulus_minus_one" }, { start: 29247, name: "tests::test_from_be_bytes_checked_rejects_modulus" }, { start: 29632, name: "tests::test_from_be_bytes_checked_rejects_modulus_plus_one" }, { start: 30076, name: "tests::test_from_bytes_checked_small_n" }, { start: 30721, name: "tests::from_le_bits" }, { start: 31268, name: "tests::from_be_bits" }, { start: 31514, name: "tests::test_to_from_be_bits_bn254_edge_cases" }, { start: 33447, name: "tests::test_to_from_le_bits_bn254_edge_cases" }, { start: 35379, name: "tests::max_bit_size_too_large" }] }, "17": { 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', path: "std/hash/mod.nr", function_locations: [{ start: 572, name: "sha256_compression" }, { start: 707, name: "keccakf1600" }, { start: 852, name: "blake2s" }, { start: 950, name: "blake3" }, { start: 1437, name: "__blake3" }, { start: 1555, name: "pedersen_commitment" }, { start: 1784, name: "pedersen_commitment_with_separator" }, { start: 2188, name: "pedersen_hash" }, { start: 2345, name: "pedersen_hash_with_separator" }, { start: 3339, name: "derive_generators" }, { start: 3698, name: "__derive_generators" }, { start: 3776, name: "poseidon2_permutation" }, { start: 4132, name: "poseidon2_permutation_internal" }, { start: 4225, name: "poseidon2_config_state_size" }, { start: 4536, name: "derive_hash" }, { start: 5327, name: "Hasher::finish_ref" }, { start: 5761, name: "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher" }, { start: 5893, name: "<impl Default for BuildHasherDefault<H>>::default" }, { start: 6025, name: "<impl Hash for Field>::hash" }, { start: 6155, name: "<impl Hash for u8>::hash" }, { start: 6295, name: "<impl Hash for u16>::hash" }, { start: 6435, name: "<impl Hash for u32>::hash" }, { start: 6575, name: "<impl Hash for u64>::hash" }, { start: 6716, name: "<impl Hash for u128>::hash" }, { start: 6855, name: "<impl Hash for i8>::hash" }, { start: 7001, name: "<impl Hash for i16>::hash" }, { start: 7148, name: "<impl Hash for i32>::hash" }, { start: 7295, name: "<impl Hash for i64>::hash" }, { start: 7443, name: "<impl Hash for bool>::hash" }, { start: 7590, name: "<impl Hash for ()>::hash" }, { start: 7722, name: "<impl Hash for [T; N]>::hash" }, { start: 7911, name: "<impl Hash for [T]>::hash" }, { start: 8133, name: "<impl Hash for (A,)>::hash" }, { start: 8302, name: "<impl Hash for (A, B)>::hash" }, { start: 8518, name: "<impl Hash for (A, B, C)>::hash" }, { start: 8781, name: "<impl Hash for (A, B, C, D)>::hash" }, { start: 9091, name: "<impl Hash for (A, B, C, D, E)>::hash" }, { start: 9448, name: "<impl Hash for (A, B, C, D, E, F)>::hash" }, { start: 9852, name: "<impl Hash for (A, B, C, D, E, F, G)>::hash" }, { start: 10306, name: "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash" }, { start: 10807, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash" }, { start: 11355, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash" }, { start: 11950, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash" }, { start: 12593, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash" }, { start: 13187, name: "assert_pedersen" }] }, "52": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crisp_lib::ciphertext_addition::verify_slot_update;\nuse crisp_lib::ecdsa::{address_to_field, derive_address, digest_from_halves, validate_signature};\nuse crisp_lib::merkle_tree::get_merkle_root;\nuse crisp_lib::utils::{check_coefficient_values_with_balance, check_coefficient_zero};\nuse interfold_lib::configs::default::threshold::{\n L, N, QIS, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_K,\n};\nuse interfold_lib::math::{\n commitments::{compute_single_polynomial_commitment, DS_USER_DATA_ENCRYPTION_COMMITMENT},\n polynomial::Polynomial,\n};\n\n/// Main circuit function for CRISP vote verification.\n///\n/// This circuit implements the core verification logic for the CRISP (Coercion-Resistant Impartial\n/// Selection Protocol) voting system. It verifies that votes are properly encrypted using BFV\n/// (Brakerski-Fan-Vercauteren) fully homomorphic encryption, and it covers three operations:\n/// 1. **Voting**: An eligible voter casts a ballot into an empty slot\n/// 2. **Updating**: The same voter replaces the ballot in their slot\n/// 3. **Masking**: Anyone adds a zero ballot to any eligible slot\n///\n/// Votes are stored in an on-chain Merkle tree, where each vote ciphertext is stored at a specific\n/// index. A mapping stores the slot address (Ethereum address) to the index in the Merkle tree.\n/// - For actual votes: the slot address must match the address derived from the signature\n/// - For mask votes: the slot address can be any address (no address match required)\n/// In both cases, the address of the slot must be in the eligibility Merkle tree, a tree used\n/// to represent all token holders eligible to vote.\n///\n/// Mask votes weaken receipt sharing: anyone can submit a zero vote to any slot, which creates a\n/// different ciphertext that decrypts to the same value. The on-chain activity of a slot then does\n/// not show which ciphertext holds its owner's vote. This holds only while the committee does not\n/// decrypt individual ballots and the public tally does not itself show the choice.\n///\n/// # One relation for all three operations\n///\n/// The circuit proves the same statement whichever operation is being performed:\n///\n/// ```text\n/// new slot ciphertext = addend + ballot ciphertext\n/// ```\n///\n/// where the ballot ciphertext is a fresh BFV encryption of `k1`, and the addend is the ciphertext\n/// already in the slot for a mask, or the zero ciphertext for a vote, an update, and any input to\n/// an empty slot. `is_mask_vote` chooses between them and is private, so the returned commitment,\n/// the public inputs, and the published ciphertext have the same shape in every case. An observer\n/// cannot tell a vote from an update from a mask; distinguishing them would mean distinguishing a\n/// fresh BFV ciphertext from a sum, which is what the encryption scheme hides.\n///\n/// The circuit returns:\n/// - `sum_ct_commitment` - the commitment to the ciphertext that becomes the slot, and the value\n/// the E3 program stores and the ballot digest is built over\n/// - `ct_commitment` - the commitment to the ballot ciphertext, which ties this proof to the\n/// `user_data_encryption` proof in the fold circuit\n/// - `k1_commitment` - the commitment to the ballot plaintext, for the same reason\n///\nfn main(\n // Ciphertext Addition Section\n prev_ct0is: [Polynomial<N>; L],\n prev_ct1is: [Polynomial<N>; L],\n prev_ct_commitment: pub Field,\n sum_ct0is: [Polynomial<N>; L],\n sum_ct1is: [Polynomial<N>; L],\n sum_r0is: [Polynomial<N>; L],\n sum_r1is: [Polynomial<N>; L],\n // User Data Encryption Section.\n ct0is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n k1: Polynomial<N>,\n // ECDSA Section.\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n digest_hi: pub Field,\n digest_lo: pub Field,\n // Eligibility Section. `slot_address` comes first so that the public inputs align with the\n // `crisp_onchain` circuit, where `voting_power` takes the position of `merkle_root`.\n slot_address: pub Field,\n merkle_root: pub Field,\n balance: Field,\n merkle_proof_length: u32,\n merkle_proof_indices: [bool; 20],\n merkle_proof_siblings: [Field; 20],\n // Other inputs.\n is_first_vote: pub bool,\n is_mask_vote: bool,\n num_options: pub u32,\n) -> pub (Field, Field, Field) {\n // ============================================================================\n // STEP 1: The Plaintext Commitment\n // ============================================================================\n // Links this circuit to the user_data_encryption proof in the fold circuit, which covers the\n // same plaintext.\n let k1_commitment = compute_single_polynomial_commitment::<N, USER_DATA_ENCRYPTION_BIT_K>(\n k1,\n DS_USER_DATA_ENCRYPTION_COMMITMENT,\n );\n\n // ============================================================================\n // STEP 2: Eligibility - Merkle Tree Proof\n // ============================================================================\n // Verify that the (slot_address, balance) pair exists in the eligibility\n // Merkle tree. The proof demonstrates membership without revealing the entire tree.\n // The leaf is computed as poseidon_hash(address, balance). The root is compared to\n // the expected root, which is stored in the contract and passed as a public input\n // when verifying the proof.\n //\n // This check applies to every operation:\n // - For actual votes: verifies the voter is eligible\n // - For mask votes: verifies the slot address is in the eligibility tree\n let merkle_root_calculated = get_merkle_root(\n slot_address,\n balance,\n merkle_proof_length,\n merkle_proof_indices,\n merkle_proof_siblings,\n );\n\n assert(merkle_root_calculated == merkle_root);\n\n // ============================================================================\n // STEP 3: The Slot Update\n // ============================================================================\n // Prove that sum_ct = addend + ct, where ct = (ct0is, ct1is) is the ballot ciphertext,\n // sum_ct = (sum_ct0is, sum_ct1is) is what the E3 program will store for this slot, and the\n // addend is the slot's current ciphertext for a mask and zero otherwise. A mask must open\n // `prev_ct_commitment`, the commitment the E3 program recorded for the entry this input names as\n // its parent.\n //\n // Asserted on every path. That is what constrains the published ciphertext: it is the ballot\n // the `user_data_encryption` proof covers, added to the ciphertext the slot already held, and\n // nothing else. Without it a submitter could publish arbitrary bytes into someone's slot.\n let (sum_ct_commitment, ct_commitment) = verify_slot_update::<N, L, USER_DATA_ENCRYPTION_BIT_CT>(\n QIS,\n prev_ct0is,\n prev_ct1is,\n prev_ct_commitment,\n sum_ct0is,\n sum_ct1is,\n sum_r0is,\n sum_r1is,\n ct0is,\n ct1is,\n is_first_vote,\n is_mask_vote,\n );\n\n // ============================================================================\n // STEP 4: Ballot Rules\n // ============================================================================\n // CASE 1: ACTUAL VOTE (is_mask_vote == false)\n // - This is an eligible voter casting or replacing a ballot\n // - Verify the ballot is well formed and worth no more than the balance (valid_vote)\n // - Validate the signature over the public digest (valid_signature) to authenticate the\n // voter for this ballot\n // - Verify the signing address matches the slot address (valid_address)\n //\n // CASE 2: MASK VOTE (is_mask_vote == true)\n // - This is anyone adding a zero ballot to mask slot activity\n // - Verify the plaintext is zero everywhere (valid_zero_vote), so a mask cannot change what\n // the slot decrypts to, and cannot carry a payload a coercer could read back out of the\n // tally\n // - No signature is required, which is what lets a third party mask a slot at all\n let valid_vote = check_coefficient_values_with_balance(k1, balance, num_options);\n\n // The digest is a public input, so the prover cannot select the message that the signature\n // covers. The contract computes the digest from the round, the slot, and this ballot, which\n // binds the signature to all three.\n let hashed_message = digest_from_halves(digest_hi, digest_lo);\n let valid_signature = validate_signature(hashed_message, public_key_x, public_key_y, signature);\n let valid_address =\n slot_address == address_to_field(derive_address(public_key_x, public_key_y));\n\n let valid_zero_vote = check_coefficient_zero(k1, num_options);\n\n if is_mask_vote {\n assert(valid_zero_vote);\n } else {\n assert(valid_vote);\n assert(valid_signature);\n assert(valid_address);\n }\n\n (sum_ct_commitment, ct_commitment, k1_commitment)\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/bin/crisp/src/main.nr", function_locations: [{ start: 4513, name: "main" }] }, "53": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! # The slot update every CRISP input proves\n//!\n//! Voting, updating, and masking all prove one relation between three BFV ciphertexts:\n//!\n//! ```text\n//! published slot ciphertext = addend + ballot ciphertext (mod q_i, coefficient by coefficient)\n//! ```\n//!\n//! The addend is the ciphertext already in the slot for a mask, and the zero ciphertext for a\n//! vote, an update, and any input to an empty slot. [`verify_slot_update`] is the one place both\n//! ballot circuits (`crisp` and `crisp_onchain`) prove it.\n//!\n//! ## Why the relation is checked at every coefficient\n//!\n//! The three ciphertexts reach the rest of the protocol only through their SAFE commitments: the\n//! ballot\'s through the `user_data_encryption` fold, the parent\'s through the commitment\n//! `CRISPProgram` stored for it, and the result\'s through the bytes the Secure Process opens. Those\n//! commitments pack coefficients into shared carriers with `pack`, which is not injective: a\n//! coefficient can overflow its slot and cancel against the next one, so a prover can open a\n//! commitment to coefficients other than the committed ones.\n//!\n//! A check at one Fiat-Shamir point cannot survive that. The point depends only on the\n//! commitments, so a prover fixes it first and then picks an opening, or quotients, that satisfy\n//! the one equation. That is how a mask could publish a ciphertext that drops the vote it names.\n//!\n//! The relation here is linear and aligned coefficient by coefficient across the three\n//! ciphertexts, which all pack with the same `BIT_CT` layout. An opening that keeps the carriers\n//! of a commitment differs from the committed coefficients by a vector the packing sends to zero.\n//! Summing the per-coefficient equations with the carrier weights therefore gives the same\n//! equation for the committed coefficients:\n//!\n//! ```text\n//! sum_k (published_k - ballot_k - addend_k) * radix^(g-1-k) = q_i * sum_k r_k * radix^(g-1-k)\n//! ```\n//!\n//! The committed coefficients are bounded (the ballot by `user_data_encryption`, the parent and the\n//! result by their canonical bytes) and each `r_k` is in `[-1, 1]`, so both sides are far below the\n//! field modulus and every base-`radix` digit fits its slot. The equation then holds over the\n//! integers digit by digit, which is `published_k = ballot_k + addend_k + q_i * r_k` for the\n//! committed coefficients. No choice of opening changes what the relation proves, so the packing\n//! does not need the digit asserts of `pack_checked`, which would put the ballot circuit above the\n//! browser prover\'s `2^21` gate ceiling.\n\nuse interfold_lib::math::commitments::compute_ciphertext_commitment;\nuse interfold_lib::math::polynomial::Polynomial;\n\n/// The ciphertext an input adds to, which is either the one already in the slot or nothing.\n///\n/// A mask keeps what the slot holds, so its addend is that ciphertext. A real vote replaces the\n/// slot, and a first input has nothing to replace, so both add to the zero ciphertext instead.\n///\n/// Selecting here rather than branching keeps the addition constraints live on every path. The\n/// alternative \u2014 proving the addition only for masks \u2014 leaves the published ciphertext of a real\n/// vote unconstrained, and makes the two paths different shapes of proof.\n///\n/// # Arguments\n/// * `polynomials` - The ciphertext limbs already in the slot\n/// * `keep` - Whether this input adds to them\n///\n/// # Returns\n/// The limbs when `keep` is true, all zeros otherwise.\npub fn select_addend<let N: u32, let L: u32>(\n polynomials: [Polynomial<N>; L],\n keep: bool,\n) -> [Polynomial<N>; L] {\n let factor: Field = if keep { 1 } else { 0 };\n\n let mut selected = polynomials;\n for i in 0..L {\n selected[i] = polynomials[i].mul_scalar(factor);\n }\n\n selected\n}\n\n/// Constrains the slot update of one CRISP input and returns the commitments it links to.\n///\n/// Proves `sum = addend + ballot` coefficient by coefficient, where the addend is the slot\'s\n/// current ciphertext for a mask and zero otherwise. The selector is derived, not witnessed:\n/// `keep_previous = is_mask_vote & !is_first_vote`. A voter therefore cannot add a new ballot on\n/// top of an old one and count twice, and a masker cannot discard what the slot holds.\n///\n/// A mask must open `prev_ct_commitment`, the commitment `CRISPProgram` stored for the entry the\n/// input names as its parent. A vote adds to nothing and opens nothing, so it can write to its own\n/// slot whatever the parent turns out to be: `CRISPProgram` cannot tell whether a parent\'s bytes\n/// reproduce its commitment, and only the Secure Process can, once the input window closes.\n///\n/// # Arguments\n/// * `qis` - The CRT moduli\n/// * `prev_ct0is`, `prev_ct1is` - The ciphertext already in the slot\n/// * `prev_ct_commitment` - The commitment `CRISPProgram` stored for the parent entry, or zero\n/// * `sum_ct0is`, `sum_ct1is` - The ciphertext this input publishes as the slot\n/// * `sum_r0is`, `sum_r1is` - The per-coefficient quotients of the addition, each in `[-1, 1]`\n/// * `ct0is`, `ct1is` - The ballot ciphertext, which `user_data_encryption` proves\n/// * `is_first_vote` - Whether the input names no parent\n/// * `is_mask_vote` - Whether the input keeps what the slot holds\n///\n/// # Returns\n/// `(sum_ct_commitment, ct_commitment)`: the commitment the slot takes, and the ballot commitment\n/// the fold links to `user_data_encryption`.\npub fn verify_slot_update<let N: u32, let L: u32, let BIT_CT: u32>(\n qis: [Field; L],\n prev_ct0is: [Polynomial<N>; L],\n prev_ct1is: [Polynomial<N>; L],\n prev_ct_commitment: Field,\n sum_ct0is: [Polynomial<N>; L],\n sum_ct1is: [Polynomial<N>; L],\n sum_r0is: [Polynomial<N>; L],\n sum_r1is: [Polynomial<N>; L],\n ct0is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n is_first_vote: bool,\n is_mask_vote: bool,\n) -> (Field, Field) {\n let ct_commitment = compute_ciphertext_commitment::<N, L, BIT_CT>(ct0is, ct1is);\n let sum_ct_commitment = compute_ciphertext_commitment::<N, L, BIT_CT>(sum_ct0is, sum_ct1is);\n\n let keep_previous = is_mask_vote & !is_first_vote;\n // Computed on every path, so the three operations prove the same shape of statement.\n let recomputed_prev_ct_commitment =\n compute_ciphertext_commitment::<N, L, BIT_CT>(prev_ct0is, prev_ct1is);\n if keep_previous {\n assert(\n prev_ct_commitment == recomputed_prev_ct_commitment,\n "the addend does not open the parent commitment",\n );\n }\n\n let addend_ct0is = select_addend(prev_ct0is, keep_previous);\n let addend_ct1is = select_addend(prev_ct1is, keep_previous);\n\n for i in 0..L {\n // The sum of two coefficients in `(-q_i, q_i)` differs from its centered residue by at\n // most one `q_i`, so `[-1, 1]` covers every honest quotient. The bound is also what lets\n // the per-coefficient equations hold over the integers.\n sum_r0is[i].range_check_2bounds::<1>(1, 1);\n sum_r1is[i].range_check_2bounds::<1>(1, 1);\n\n for k in 0..N {\n assert(\n sum_ct0is[i].coefficients[k]\n == ct0is[i].coefficients[k]\n + addend_ct0is[i].coefficients[k]\n + qis[i] * sum_r0is[i].coefficients[k],\n "the published ciphertext is not the ballot added to the addend",\n );\n assert(\n sum_ct1is[i].coefficients[k]\n == ct1is[i].coefficients[k]\n + addend_ct1is[i].coefficients[k]\n + qis[i] * sum_r1is[i].coefficients[k],\n "the published ciphertext is not the ballot added to the addend",\n );\n }\n }\n\n (sum_ct_commitment, ct_commitment)\n}\n\n// ---------------------------------------------------------------------------\n// Tests\n// ---------------------------------------------------------------------------\n//\n// Reduced dimensions: four coefficients, one small modulus, and a 16-bit packing layout (a radix\n// of 2^20, twelve digits per carrier). The relation and the packing are the production functions.\n\nglobal TEST_N: u32 = 4;\nglobal TEST_L: u32 = 1;\nglobal TEST_BIT_CT: u32 = 16;\nglobal TEST_Q: Field = 40961;\nglobal TEST_QIS: [Field; TEST_L] = [TEST_Q];\n\nfn ciphertext(\n c0: [Field; TEST_N],\n c1: [Field; TEST_N],\n) -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ([Polynomial::new(c0)], [Polynomial::new(c1)])\n}\n\nfn commit(ct: ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L])) -> Field {\n compute_ciphertext_commitment::<TEST_N, TEST_L, TEST_BIT_CT>(ct.0, ct.1)\n}\n\nfn no_quotients() -> [Polynomial<TEST_N>; TEST_L] {\n [Polynomial::new([0; TEST_N])]\n}\n\n/// The ciphertext already in the slot.\nfn slot_head() -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ciphertext([1200, -3400, 20000, 17], [-9, 8000, -20000, 5])\n}\n\n/// A fresh ballot ciphertext.\nfn ballot() -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ciphertext([300, 45, 1000, -2], [7, -600, -1000, 11])\n}\n\n#[test]\nfn a_vote_publishes_its_ballot_alone() {\n let ballot = ballot();\n let empty = ciphertext([0; TEST_N], [0; TEST_N]);\n\n let (sum_commitment, ct_commitment) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n empty.0,\n empty.1,\n 0,\n ballot.0,\n ballot.1,\n no_quotients(),\n no_quotients(),\n ballot.0,\n ballot.1,\n true,\n false,\n );\n\n assert(sum_commitment == commit(ballot));\n assert(ct_commitment == commit(ballot));\n}\n\n/// An update names the slot\'s head as its parent but replaces it, so it adds to nothing.\n#[test]\nfn an_update_replaces_the_ballot_in_the_slot() {\n let head = slot_head();\n let ballot = ballot();\n\n let (sum_commitment, _) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n ballot.0,\n ballot.1,\n no_quotients(),\n no_quotients(),\n ballot.0,\n ballot.1,\n false,\n false,\n );\n\n assert(sum_commitment == commit(ballot));\n}\n\n/// A mask keeps the ballot in the slot. Two coefficients wrap past `q / 2` and need the quotient.\n#[test]\nfn a_mask_keeps_the_ballot_in_the_slot() {\n let head = slot_head();\n let mask = ballot();\n // 20000 + 1000 = 21000 wraps to 21000 - q, and -20000 - 1000 = -21000 wraps to q - 21000.\n let sum = ciphertext(\n [1500, -3355, 21000 - TEST_Q, 15],\n [-2, 7400, TEST_Q - 21000, 16],\n );\n let r0 = [Polynomial::new([0, 0, -1, 0])];\n let r1 = [Polynomial::new([0, 0, 1, 0])];\n\n let (sum_commitment, _) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n sum.0,\n sum.1,\n r0,\n r1,\n mask.0,\n mask.1,\n false,\n true,\n );\n\n assert(sum_commitment == commit(sum));\n}\n\n#[test(should_fail_with = "the published ciphertext is not the ballot added to the addend")]\nfn a_mask_cannot_publish_its_ballot_without_the_slot() {\n let head = slot_head();\n let mask = ballot();\n\n let _ = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n mask.0,\n mask.1,\n no_quotients(),\n no_quotients(),\n mask.0,\n mask.1,\n false,\n true,\n );\n}\n\n/// The demonstrated forgery: a mask that publishes only its own ballot, and so erases the vote in\n/// the slot, with a second opening of the parent commitment.\n///\n/// The parent opening differs from the head only by `delta * v`, where `v = (1, -radix, 0, 0)` is a\n/// carry that the packing maps to zero, so it opens the same commitment. A check at one\n/// Fiat-Shamir point derived from the three commitments accepted it once `delta` solved that one\n/// equation. The attacker computes that point the way such a check derived it.\n#[test(should_fail_with = "the published ciphertext is not the ballot added to the addend")]\nfn a_second_opening_of_the_parent_cannot_erase_the_slot() {\n let head = slot_head();\n let mask = ballot();\n let parent_commitment = commit(head);\n let published_commitment = commit(mask);\n\n let domain_separator: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x43, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ];\n let gammas = interfold_lib::math::commitments::compute_challenge::<TEST_L>(\n [published_commitment, parent_commitment, published_commitment].as_vector(),\n domain_separator,\n );\n let gamma = gammas[0];\n\n // The single-point check was `(published0 - ballot0 - addend0)(gamma) +\n // gammas[1] * (published1 - ballot1 - addend1)(gamma) == 0` with zero quotients. Publishing the\n // mask ballot alone leaves `addend0(gamma) = -gammas[1] * head1(gamma)`.\n let radix: Field = 1048576;\n let carry = Polynomial::new([1, -radix, 0, 0]);\n let delta = (0 - gammas[1] * head.1[0].eval(gamma) - head.0[0].eval(gamma)) / carry.eval(gamma);\n let forged0 = [head.0[0].add(carry.mul_scalar(delta))];\n\n assert(\n compute_ciphertext_commitment::<TEST_N, TEST_L, TEST_BIT_CT>(forged0, head.1)\n == parent_commitment,\n "the forged opening must open the parent commitment",\n );\n\n let _ = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n forged0,\n head.1,\n parent_commitment,\n mask.0,\n mask.1,\n no_quotients(),\n no_quotients(),\n mask.0,\n mask.1,\n false,\n true,\n );\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/ciphertext_addition.nr", function_locations: [{ start: 3798, name: "select_addend" }, { start: 6074, name: "verify_slot_update" }, { start: 8622, name: "ciphertext" }, { start: 8763, name: "commit" }, { start: 8895, name: "no_quotients" }, { start: 9054, name: "slot_head" }, { start: 9230, name: "ballot" }, { start: 9340, name: "a_vote_publishes_its_ballot_alone" }, { start: 9976, name: "an_update_replaces_the_ballot_in_the_slot" }, { start: 10542, name: "a_mask_keeps_the_ballot_in_the_slot" }, { start: 11372, name: "a_mask_cannot_publish_its_ballot_without_the_slot" }, { start: 12398, name: "a_second_opening_of_the_parent_cannot_erase_the_slot" }] }, "55": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\n\n/// Validates an ECDSA signature over a hashed message.\n///\n/// This function validates that a signature was created by the holder of the private key\n/// corresponding to the provided public key, and that it signs the given hashed message.\n///\n/// # Arguments\n/// * `hashed_message` - The Keccak256 hash of the message being signed (32 bytes)\n/// * `pub_key_x` - The x-coordinate of the public key (32 bytes, big-endian)\n/// * `pub_key_y` - The y-coordinate of the public key (32 bytes, big-endian)\n/// * `signature` - The ECDSA signature (64 bytes: r || s, both 32 bytes big-endian)\n///\n/// # Returns\n/// Returns `true` if the signature is valid, `false` otherwise.\n///\n/// # Note\n/// The signature is verified using secp256k1 curve (same as Ethereum). The message\n/// should already be hashed before calling this function.\npub fn validate_signature(\n hashed_message: [u8; 32],\n pub_key_x: [u8; 32],\n pub_key_y: [u8; 32],\n signature: [u8; 64],\n) -> bool {\n std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message)\n}\n\n/// Derives an Ethereum address from a secp256k1 public key.\n///\n/// This function implements the standard Ethereum address derivation algorithm:\n/// 1. Concatenate the public key coordinates (64 bytes total)\n/// 2. Compute Keccak256 hash of the concatenated bytes\n/// 3. Extract the last 20 bytes as the address\n///\n/// # Arguments\n/// * `pub_key_x` - The x-coordinate of the public key (32 bytes, big-endian)\n/// * `pub_key_y` - The y-coordinate of the public key (32 bytes, big-endian)\n///\n/// # Returns\n/// A 20-byte array representing the Ethereum address.\npub fn derive_address(pub_key_x: [u8; 32], pub_key_y: [u8; 32]) -> [u8; 20] {\n let mut pub_key_bytes = [0; 64];\n for i in 0..32 {\n pub_key_bytes[i] = pub_key_x[i];\n pub_key_bytes[i + 32] = pub_key_y[i];\n }\n\n // Hash the concatenated public key\n let hash = keccak256(pub_key_bytes, 64);\n\n // Extract last 20 bytes as the Ethereum address\n let mut derived_address = [0; 20];\n for i in 0..20 {\n derived_address[i] = hash[i + 12];\n }\n\n derived_address\n}\n\n/// Converts a 20-byte Ethereum address to a field element.\n///\n/// This function interprets the address bytes as a big-endian integer and converts it\n/// to a field element.\n///\n/// # Arguments\n/// * `addr` - A 20-byte Ethereum address\n///\n/// # Returns\n/// A field element representing the address as an integer.\npub fn address_to_field(addr: [u8; 20]) -> Field {\n let mut acc: Field = 0;\n\n for i in 0..20 {\n acc = acc * 256 + (addr[i] as Field);\n }\n\n acc\n}\n\n/// Rebuilds the 32-byte signed digest from its two field halves.\n///\n/// A Keccak-256 digest is 256 bits, but a field element holds fewer than 254 bits. The digest\n/// therefore enters a circuit as two public inputs. `digest_hi` holds the first 16 bytes and\n/// `digest_lo` holds the last 16 bytes. Both halves are big-endian.\n///\n/// `to_be_bytes` constrains each half to 16 bytes, so each half has one representation only.\n///\n/// # Arguments\n/// * `digest_hi` - The first 16 bytes of the digest, as a big-endian integer\n/// * `digest_lo` - The last 16 bytes of the digest, as a big-endian integer\n///\n/// # Returns\n/// The 32-byte digest.\npub fn digest_from_halves(digest_hi: Field, digest_lo: Field) -> [u8; 32] {\n let hi: [u8; 16] = digest_hi.to_be_bytes();\n let lo: [u8; 16] = digest_lo.to_be_bytes();\n\n let mut digest = [0; 32];\n for i in 0..16 {\n digest[i] = hi[i];\n digest[i + 16] = lo[i];\n }\n\n digest\n}\n\n#[test]\nfn test_derive_address() {\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let address = derive_address(pub_key_x, pub_key_y);\n assert(\n address\n == [\n 243, 159, 214, 229, 26, 173, 136, 246, 244, 206, 106, 184, 130, 114, 121, 207, 255,\n 185, 34, 102,\n ],\n );\n}\n\n#[test]\nfn test_validate_signature() {\n let hashed_message = [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104, 152,\n 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ];\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_validate_signature_sdk_input() {\n let hashed_message = [\n 200, 232, 98, 162, 80, 131, 242, 57, 252, 76, 226, 45, 127, 206, 207, 39, 206, 44, 211, 171,\n 113, 67, 121, 68, 78, 253, 202, 79, 29, 128, 130, 76,\n ];\n\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 22, 65, 67, 29, 14, 211, 253, 134, 129, 79, 2, 109, 166, 46, 17, 67, 75, 83, 198, 168, 81,\n 98, 254, 167, 249, 146, 24, 191, 60, 48, 125, 236, 127, 54, 28, 35, 95, 7, 182, 88, 120, 10,\n 253, 145, 165, 201, 214, 141, 106, 75, 20, 213, 235, 5, 17, 246, 104, 141, 62, 145, 20, 14,\n 236, 18,\n ];\n\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_digest_from_halves() {\n let digest = digest_from_halves(\n 0x437e9da4a2a538f29bd671c453c6e424,\n 0xae689857a76c4022eaa17a372c3e9737,\n );\n\n assert(\n digest\n == [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104,\n 152, 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ],\n );\n}\n\n#[test]\nfn test_digest_from_halves_matches_signature() {\n // The same digest as `test_validate_signature`, supplied as two halves.\n let digest = digest_from_halves(\n 0x437e9da4a2a538f29bd671c453c6e424,\n 0xae689857a76c4022eaa17a372c3e9737,\n );\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n\n assert(validate_signature(digest, pub_key_x, pub_key_y, signature));\n}\n\n/// A signature is valid only for the digest it covers.\n///\n/// This is the property the ballot binding depends on. The digest is a public input that the\n/// contract computes from the round, the slot, and the ballot, so a signature taken from anywhere\n/// else cannot be replayed onto a different ballot. Before the digest became a public input, the\n/// message was a free witness and any signature by the slot key was accepted.\n#[test(should_fail)]\nfn test_fail_signature_over_different_digest() {\n // The key and signature of `test_validate_signature`, checked against the digest of\n // `test_validate_signature_sdk_input`.\n let other_digest = digest_from_halves(\n 0xc8e862a25083f239fc4ce22d7fcecf27,\n 0xce2cd3ab714379444efdca4f1d80824c,\n );\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n\n assert(validate_signature(other_digest, pub_key_x, pub_key_y, signature));\n}\n\n#[test(should_fail)]\nfn test_fail_digest_half_too_large() {\n // A half that needs more than 16 bytes has no unique encoding, so `to_be_bytes` must reject it.\n let _ = digest_from_halves(0x0100000000000000000000000000000000, 0);\n}\n\n#[test(should_fail)]\nfn test_fail_validate_signature() {\n // This test verifies that invalid signatures cause validation to fail.\n // The test itself will fail (assertion failure) when validate_signature is called\n // with an invalid signature, which demonstrates that invalid signatures are properly rejected.\n let hashed_message = [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104, 152,\n 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ];\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 151,\n ];\n\n // This call should fail (assertion failure) because the signature is invalid\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_address_to_field() {\n let address: [u8; 20] = [\n 243, 159, 214, 229, 26, 173, 136, 246, 244, 206, 106, 184, 130, 114, 121, 207, 255, 185, 34,\n 102,\n ];\n let field = address_to_field(address);\n\n assert(field == 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/ecdsa.nr", function_locations: [{ start: 1183, name: "validate_signature" }, { start: 1918, name: "derive_address" }, { start: 2708, name: "address_to_field" }, { start: 3541, name: "digest_from_halves" }, { start: 3804, name: "test_derive_address" }, { start: 4478, name: "test_validate_signature" }, { start: 5551, name: "test_validate_signature_sdk_input" }, { start: 6598, name: "test_digest_from_halves" }, { start: 7038, name: "test_digest_from_halves_matches_signature" }, { start: 8565, name: "test_fail_signature_over_different_digest" }, { start: 9720, name: "test_fail_digest_half_too_large" }, { start: 9954, name: "test_fail_validate_signature" }, { start: 11361, name: "test_address_to_field" }] }, "57": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse binary_merkle_root::binary_merkle_root;\nuse poseidon::poseidon::bn254::hash_2 as poseidon;\n\n/// Computes the Merkle root from a leaf value and Merkle proof.\n///\n/// This function verifies that a given (address, balance) pair exists in the eligibility\n/// Merkle tree by reconstructing the root from the leaf and proof path.\n///\n/// # Arguments\n/// * `address` - The voter\'s Ethereum address (as a field element)\n/// * `balance` - The voter\'s balance/voting power (as a field element)\n/// * `depth` - The depth of the Merkle tree (number of levels from root to leaf)\n/// * `indices` - Path direction indicators (0 = left, 1 = right) for each level\n/// * `siblings` - Sibling node values along the path from leaf to root\n///\n/// # Returns\n/// The computed Merkle root as a field element.\npub fn get_merkle_root(\n address: Field,\n balance: Field,\n depth: u32,\n indices: [bool; 20],\n siblings: [Field; 20],\n) -> Field {\n let leaf = poseidon([address, balance]);\n let merkle_root = binary_merkle_root(poseidon, leaf, depth, indices, siblings);\n\n merkle_root\n}\n\n#[test]\nfn test_get_merkle_root() {\n let address = 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266;\n let balance = 1000000000000000000;\n\n // Consider a tree with depth 3, leaves are [poseidon([address, balance]), 0, 0].\n let depth = 2;\n let indices: [bool; 20] = [false; 20];\n let siblings: [Field; 20] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n\n let merkle_root = get_merkle_root(address, balance, depth, indices, siblings);\n let expected = 0x11c1a161d2d84845a176670f3501200b4a0df1048073c0caea6ead2e71b7edaf;\n\n println(f"merkle_root: {merkle_root}");\n println(f"expected: {expected}");\n\n assert(merkle_root == expected);\n}\n\n#[test]\nfn test_get_merkle_root_ts_sdk() {\n let address = 0x1234567890123456789012345678901234567890;\n let balance = 1000;\n\n let depth = 4;\n let indices: [bool; 20] = [false; 20];\n let siblings: [Field; 20] = [\n 3427403932201889290042771220465494458496044723860771244846412090114641612933,\n 142173982782527023041821996079117549632814652929360547003021612347642943458,\n 5984039385283196232308319035002972848802042601279200765710389913462508845879,\n 13230920196039626330844247773673397239708271370016925050843639396057862269188,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n 0,\n ];\n\n let merkle_root = get_merkle_root(address, balance, depth, indices, siblings);\n let expected = 1459018155640011149834119814743866717977769794914747043488779523926892000355;\n assert(merkle_root == expected);\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/merkle_tree.nr", function_locations: [{ start: 1122, name: "get_merkle_root" }, { start: 1307, name: "test_get_merkle_root" }, { start: 1989, name: "test_get_merkle_root_ts_sdk" }] }, "58": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse interfold_lib::configs::default::MAX_MSG_NON_ZERO_COEFFS;\nuse interfold_lib::configs::default::threshold::{\n PLAINTEXT_MODULUS, Q_INVERSE_MOD_T, Q_MOD_T, USER_DATA_ENCRYPTION_BIT_K,\n};\nuse interfold_lib::math::helpers::assert_in_range;\nuse interfold_lib::math::modulo::unconstrained_U128::__compute_mod_reduction;\nuse interfold_lib::math::polynomial::Polynomial;\n\nuse crate::constants::MAX_OPTIONS;\n\n/// Checks the option count of a round. Every option must sit inside the first\n/// `MAX_MSG_NON_ZERO_COEFFS` message coefficients, which the committee publishes as the tally, and\n/// the degree `D` must hold them. The last two assertions are decided when the circuit is built.\nfn check_option_count<let D: u32>(num_options: u32) {\n assert(num_options > 1);\n assert(num_options <= MAX_OPTIONS);\n assert(MAX_OPTIONS <= MAX_MSG_NON_ZERO_COEFFS);\n assert(MAX_MSG_NON_ZERO_COEFFS <= D);\n}\n\n/// Checks that `weight` is the value the committee decrypts the option coefficient to.\n///\n/// The witness generator scales each message coefficient `m` to `k1 = (Q_MOD_T * m) mod t`, so\n/// `k1 + t * quotient == Q_MOD_T * weight`. With all three values in `[0, t)`, neither side reaches\n/// `t * t`, so the equation holds over the integers, and one weight solves it because `Q_MOD_T` is\n/// invertible modulo `t`.\n///\n/// The bound on the coefficient also makes this `k1` the plaintext that `user_data_encryption_ct0`\n/// encrypts. That circuit bounds its `k1` to `[0, t)`, the fold only checks that the two\n/// `k1_commitment` values are equal, and a packed commitment has one opening only while every\n/// coefficient fits its slot.\nfn check_weight(coefficient: Field, weight: Field, quotient: Field) {\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(coefficient, PLAINTEXT_MODULUS);\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(weight, PLAINTEXT_MODULUS);\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(quotient, PLAINTEXT_MODULUS);\n assert(coefficient + PLAINTEXT_MODULUS * quotient == Q_MOD_T * weight);\n}\n\n/// Computes the weight and the quotient that [`check_weight`] checks.\nunconstrained fn decode_weight_hint(coefficient: Field) -> (Field, Field) {\n let (_, weight) = __compute_mod_reduction(coefficient * Q_INVERSE_MOD_T, PLAINTEXT_MODULUS);\n let (quotient, _) = __compute_mod_reduction(Q_MOD_T * weight, PLAINTEXT_MODULUS);\n (weight, quotient)\n}\n\n/// Validates a ballot against the voter's balance.\n///\n/// A ballot holds one coefficient per option, so the decrypted tally holds per-option totals. `k1`\n/// is the whole BFV plaintext of degree `D`, reversed, so option `o` is `k1[D - 1 - o]`:\n///\n/// ```text\n/// [ ------------------ zero ------------------ | option n-1 | ... | option 1 | option 0 ]\n/// 0 D\n/// ```\n///\n/// Every other coefficient must be zero, so no payload outside the ballot reaches the tally. The\n/// weights must sum to at most `balance`, and with two options at most one weight is non-zero.\n///\n/// # Arguments\n/// * `k1` - The plaintext polynomial encoding the vote\n/// * `balance` - The voter's balance/voting power\n/// * `num_options` - Number of voting options\npub fn check_coefficient_values_with_balance<let D: u32>(\n k1: Polynomial<D>,\n balance: Field,\n num_options: u32,\n) -> bool {\n check_option_count::<D>(num_options);\n\n let mut valid = true;\n for i in 0..(D - MAX_OPTIONS) {\n valid = valid & (k1.coefficients[i] == 0);\n }\n\n let mut total: Field = 0;\n let mut non_zero_count: u32 = 0;\n for option in 0..MAX_OPTIONS {\n let coefficient = k1.coefficients[D - 1 - option];\n // Safety: `check_weight` constrains both values.\n let (weight, quotient) = unsafe { decode_weight_hint(coefficient) };\n check_weight(coefficient, weight, quotient);\n\n if option < num_options {\n total += weight;\n if weight != 0 {\n non_zero_count += 1;\n }\n } else {\n valid = valid & (coefficient == 0);\n }\n }\n\n if num_options == 2 {\n valid = valid & (non_zero_count <= 1);\n }\n\n // At most `MAX_OPTIONS` weights below `t` fit in a u64, so this cast is exact. Truncating the\n // balance can only lower the bound.\n valid & ((total as u64) <= (balance as u64))\n}\n\n/// Checks that every coefficient of `k1` is zero, not only the option coefficients. A mask needs no\n/// signature, so anyone may write one to any eligible slot, and a payload anywhere in it would\n/// reach that slot. `num_options` is still checked, so a mask cannot pass for a round that the\n/// vote rules refuse.\npub fn check_coefficient_zero<let D: u32>(k1: Polynomial<D>, num_options: u32) -> bool {\n check_option_count::<D>(num_options);\n\n let mut valid = true;\n for i in 0..D {\n valid = valid & (k1.coefficients[i] == 0);\n }\n valid\n}\n\n// Tests build `k1` the way the witness generator does and take `t` and `Q_MOD_T` from the compiled\n// preset, so they hold for any plaintext modulus of at least 100.\n\n/// The degree of the `insecure-64` preset, well above `MAX_OPTIONS`, so the layout is read from\n/// the real degree.\nglobal TEST_DEGREE: u32 = 64;\n\n/// The `k1` coefficient the witness generator produces for one message coefficient.\nfn scale(m: u64) -> Field {\n (((Q_MOD_T as u64) * m) % (PLAINTEXT_MODULUS as u64)) as Field\n}\n\n/// Builds `k1` the way `encodeVote` and the witness generator do: the weight of option `o`, scaled,\n/// at `k1[D - 1 - o]`, and zero everywhere else.\nfn encode_ballot<let N: u32>(weights: [u64; N]) -> Polynomial<TEST_DEGREE> {\n let mut coefficients = [0; TEST_DEGREE];\n for option in 0..N {\n coefficients[TEST_DEGREE - 1 - option] = scale(weights[option]);\n }\n Polynomial { coefficients }\n}\n\n/// Each row: the weights of options 0 to 2, the option count, the balance, and whether the vote\n/// rules accept the ballot.\n#[test]\nfn test_vote_rules() {\n let top = (PLAINTEXT_MODULUS as u64) - 1;\n let rows: [([u64; 3], u32, u64, bool); 7] = [\n ([0, 3, 0], 2, 10, true),\n ([1, 1, 0], 2, 10, false),\n // The largest weight decodes exactly, so the balance bound is tight.\n ([top, 0, 0], 2, top, true),\n ([top, 0, 0], 2, top - 1, false),\n ([40, 0, 60], 3, 100, true),\n ([60, 60, 0], 3, 100, false),\n ([0, 0, 0], 3, 100, true),\n ];\n for row in rows {\n let (weights, num_options, balance, accepted) = row;\n let pol = encode_ballot(weights);\n assert(\n check_coefficient_values_with_balance(pol, balance as Field, num_options) == accepted,\n );\n }\n}\n\n/// The last option of the largest round sits next to the coefficients that must be zero.\n#[test]\nfn test_last_option_of_largest_round_counts() {\n let pol = encode_ballot([0, 0, 0, 0, 0, 0, 0, 0, 0, 7]);\n assert(check_coefficient_values_with_balance(pol, 7, MAX_OPTIONS));\n assert(!check_coefficient_values_with_balance(pol, 6, MAX_OPTIONS));\n}\n\n/// A payload below the options, or in an option the round does not have, is refused.\n#[test]\nfn test_coefficient_outside_the_round_options_fails() {\n let mut below = encode_ballot([1, 0]);\n below.coefficients[0] = 1;\n assert(!check_coefficient_values_with_balance(below, 10, 2));\n\n // Option 3 is the first one that a three-option round does not have.\n assert(!check_coefficient_values_with_balance(encode_ballot([1, 0, 0, 1]), 10, 3));\n}\n\n/// The pair solves the equation for the coefficient `Q_MOD_T - 2 * t`, which is below zero, so\n/// only the coefficient bound refuses it.\n#[test(should_fail)]\nfn test_coefficient_below_zero_is_refused() {\n check_weight(Q_MOD_T - 2 * PLAINTEXT_MODULUS, 1, 2);\n}\n\n/// The weight `t` solves the equation for the coefficient 0 with the quotient `Q_MOD_T`, so only\n/// the weight bound refuses it.\n#[test(should_fail)]\nfn test_weight_outside_range_is_refused() {\n check_weight(0, PLAINTEXT_MODULUS, Q_MOD_T);\n}\n\n/// A weight the coefficient does not carry is refused, also with the quotient of that weight.\n#[test(should_fail)]\nfn test_weight_the_coefficient_does_not_carry_is_refused() {\n let quotient = ((Q_MOD_T as u64) * 6) / (PLAINTEXT_MODULUS as u64);\n check_weight(scale(5), 6, quotient as Field);\n}\n\n/// A quotient outside `[0, t)` solves the equation for any weight, so only the quotient bound\n/// refuses this weight of zero.\n#[test(should_fail)]\nfn test_quotient_outside_range_is_refused() {\n check_weight(scale(5), 0, -scale(5) / PLAINTEXT_MODULUS);\n}\n\n/// A mask must be zero everywhere: in the option coefficients and below them.\n#[test]\nfn test_check_coefficient_zero() {\n assert(check_coefficient_zero(encode_ballot([0, 0]), 3));\n assert(!check_coefficient_zero(encode_ballot([1, 0]), 3));\n\n let mut pol = encode_ballot([0, 0]);\n pol.coefficients[0] = 1;\n assert(!check_coefficient_zero(pol, 3));\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/utils.nr", function_locations: [{ start: 925, name: "check_option_count" }, { start: 1897, name: "check_weight" }, { start: 2364, name: "decode_weight_hint" }, { start: 3537, name: "check_coefficient_values_with_balance" }, { start: 4952, name: "check_coefficient_zero" }, { start: 5541, name: "scale" }, { start: 5839, name: "encode_ballot" }, { start: 6180, name: "test_vote_rules" }, { start: 7025, name: "test_last_option_of_largest_round_counts" }, { start: 7384, name: "test_coefficient_outside_the_round_options_fails" }, { start: 7896, name: "test_coefficient_below_zero_is_refused" }, { start: 8152, name: "test_weight_outside_range_is_refused" }, { start: 8381, name: "test_weight_the_coefficient_does_not_carry_is_refused" }, { start: 8701, name: "test_quotient_outside_range_is_refused" }, { start: 8888, name: "test_check_coefficient_zero" }] }, "59": { source: "// This circuit is designed to calculate the root of a binary Merkle\n// tree given a hash function, a leaf, its depth, and the necessary sibling\n// information (aka proof of membership).\n// A circuit is designed without the capability to iterate through\n// a dynamic array. To address this, a parameter with the static maximum\n// tree depth is defined (i.e. 'MAX_DEPTH'). And additionally, the circuit\n// receives a dynamic depth as an input, which is utilized in calculating the\n// true root of the Merkle tree. The actual depth of the Merkle tree\n// may be equal to or less than the static maximum depth.\npub fn binary_merkle_root<let MAX_DEPTH: u32>(\n hasher: fn([Field; 2]) -> Field,\n leaf: Field,\n depth: u32,\n indices: [bool; MAX_DEPTH],\n siblings: [Field; MAX_DEPTH],\n) -> Field {\n // Start from the leaf node\n let mut node = leaf;\n\n // Iterate through the Merkle proof up to MAX_DEPTH\n for i in 0..MAX_DEPTH {\n // Only compute hash if the current level is within the tree depth\n if i < depth {\n let sibling = siblings[i];\n\n // Determine the ordering of node and sibling based on the index bit\n // If indices[i] == 0, node is on the left; otherwise, it's on the right\n let (left, right) = if !indices[i] {\n (node, sibling)\n } else {\n (sibling, node)\n };\n\n // Hash the pair to move one level up the tree\n node = hasher([left, right]);\n }\n }\n\n // Return the root computed\n node\n}\n", path: "/Users/ctrlc03/nargo/github.com/gnosisguild/zk-kit.noir/v0.0.3/packages/binary-merkle-root/src/lib.nr", function_locations: [{ start: 801, name: "binary_merkle_root" }] }, "93": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::helpers::{compute_safe, flatten, flatten_checked};\nuse crate::math::polynomial::Polynomial;\n\n/// DOMAIN SEPARATORS\n\n// Domain separator - "PK"\npub global DS_PK: [u8; 64] = [\n 0x50, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_GENERATION"\npub global DS_PK_GENERATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_COMPUTATION"\npub global DS_SHARE_COMPUTATION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_ENCRYPTION"\npub global DS_SHARE_ENCRYPTION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_AGGREGATION"\npub global DS_PK_AGGREGATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CIPHERTEXT"\npub global DS_CIPHERTEXT: [u8; 64] = [\n 0x43, 0x49, 0x50, 0x48, 0x45, 0x52, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "AGGREGATED_SHARES"\npub global DS_AGGREGATED_SHARES: [u8; 64] = [\n 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45,\n 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "VK_HASH"\npub global DS_VK_HASH: [u8; 64] = [\n 0x56, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "RECURSIVE_AGGREGATION"\npub global DS_RECURSIVE_AGGREGATION: [u8; 64] = [\n 0x52, 0x45, 0x43, 0x55, 0x52, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47,\n 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_PK_GENERATION"\npub global DS_CLG_PK_GENERATION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_ENCRYPTION"\npub global DS_CLG_SHARE_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_USER_DATA_ENCRYPTION"\npub global DS_CLG_USER_DATA_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e,\n 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_DECRYPTION"\npub global DS_CLG_SHARE_DECRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "THRESHOLD_DECRYPTION_SHARE"\npub global DS_THRESHOLD_DECRYPTION_SHARE: [u8; 64] = [\n 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "USER_DATA_ENCRYPTION_COMMITMENT"\npub global DS_USER_DATA_ENCRYPTION_COMMITMENT: [u8; 64] = [\n 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n/// WRAPPERS\n\npub fn compute_commitment(inputs: [Field], domain_separator: [u8; 64]) -> Field {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 1])[0]\n}\n\npub fn compute_single_polynomial_commitment<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_single_polynomial_commitment`] with the digit asserts, for a polynomial this circuit\n/// carries no bound for. ct1 commits `u` this way: ct0 range-checks the same `u` to `u_bound` and the\n/// `user_data_encryption` fold asserts the two `u` commitments are equal, so making ct1\'s packing\n/// injective is what forces its `u` to equal ct0\'s \u2014 the bound transfers instead of being repeated.\n/// Produces the same value as the plain version for any input the plain version could legitimately\n/// have committed.\npub fn compute_single_polynomial_commitment_checked<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_multiple_polynomial_commitment<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_challenge<let L: u32>(inputs: [Field], domain_separator: [u8; 64]) -> [Field] {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 2 * L])\n}\n\npub fn single_polynomial_payload<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\npub fn single_polynomial_payload_checked<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload_checked<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n payload = multiple_polynomial_payload::<N, L, BIT_PK>(payload, pk1);\n\n compute_commitment(payload, DS_PK)\n}\n\npub fn compute_threshold_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\n/// [`compute_multiple_polynomial_commitment`] for a circuit that **opens** this commitment.\npub fn compute_multiple_polynomial_commitment_checked<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_threshold_pk_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C5). Asserts each packed digit fits its slot, which makes the opening unique and so\n/// forces the opened `pk0` to equal the `pk0` C1 committed. Produces the same value as the plain\n/// helper, so C1 needs no change.\npub fn compute_threshold_pk_commitment_checked<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\npub fn compute_share_computation_sk_commitment<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\n/// [`compute_share_computation_sk_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2a). C1 creates it and bounds `sk` to the trinary range, so making the opening\n/// unique forces the witness to equal that `sk`.\npub fn compute_share_computation_sk_commitment_checked<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_computation_e_sm_commitment<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_encryption_commitment_from_message<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\n/// [`compute_share_encryption_commitment_from_message`] for a circuit that **opens** this\n/// commitment rather than creating it (C4). Asserts each packed digit fits its slot, forcing the\n/// opened share to equal the share C2 committed. Same value as the plain helper, so C2 and C3 need\n/// no change.\npub fn compute_share_encryption_commitment_from_message_checked<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\npub fn compute_aggregated_shares_commitment<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// Commitment to a threshold decryption share: all CRT limbs, first `K` coefficients per limb\n/// (same layout as `Polynomial<K>` in decrypted_shares_aggregation).\n///\n/// `NATIVE_BIT_WIDTH` must cover native coefficients in \\([0, q_l)\\) per limb (not centered `d` bounds).\npub fn compute_threshold_decryption_share_commitment<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload =\n multiple_polynomial_payload::<K, L, NATIVE_BIT_WIDTH>([].as_vector(), d_share_limbs);\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_threshold_decryption_share_commitment`] for a circuit that **opens** this commitment\n/// rather than creating it (C7). C6 creates it and pins each coefficient to a native residue in\n/// \\([0, q)\\) via `verify_d_native_trunc_binding`, so asserting the digits here makes the opening\n/// unique and forces the opened share to equal the one C6 committed. Produces the same value as the\n/// plain version for any input the plain version could legitimately have committed.\npub fn compute_threshold_decryption_share_commitment_checked<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<K, L, NATIVE_BIT_WIDTH>(\n [].as_vector(),\n d_share_limbs,\n );\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_share_computation_e_sm_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2b). C1 creates it and bounds each `e_sm` limb to a centered residue.\npub fn compute_share_computation_e_sm_commitment_checked<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_pk_aggregation_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let commit_pk0 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk0, DS_PK_AGGREGATION);\n let commit_pk1 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk1, DS_PK_AGGREGATION);\n\n let inputs = [commit_pk0, commit_pk1].as_vector();\n\n compute_commitment(inputs, DS_PK_AGGREGATION)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: [Field]) -> Field {\n compute_commitment(payload, DS_RECURSIVE_AGGREGATION)\n}\n\npub fn compute_vk_hash(vk_hashes: [Field]) -> Field {\n compute_commitment(vk_hashes, DS_VK_HASH)\n}\n\n/// [`compute_aggregated_shares_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). C4 creates it after `normalize_aggregated` has reduced and centered the\n/// aggregate, so making the opening unique forces the witness to equal that canonical value.\npub fn compute_aggregated_shares_commitment_checked<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// [`compute_ciphertext_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). No upstream circuit bounds the ciphertext limbs, so this buys injectivity\n/// rather than canonicality \u2014 which is the property wanted here: it forces C6 to decrypt exactly\n/// the ciphertext that was committed, whatever its representation.\npub fn compute_ciphertext_commitment_checked<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\npub fn compute_ciphertext_commitment<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: [Field]) -> Field {\n compute_commitment(payload, DS_CLG_PK_GENERATION)\n}\n\npub fn compute_share_encryption_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_SHARE_ENCRYPTION)\n}\n\npub fn compute_threshold_share_decryption_challenge<let L: u32>(payload: [Field]) -> Field {\n compute_challenge::<L>(payload, DS_CLG_SHARE_DECRYPTION)[0]\n}\n\npub fn compute_user_data_encryption_ct0_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n\npub fn compute_user_data_encryption_ct1_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/commitments.nr", function_locations: [{ start: 7784, name: "compute_commitment" }, { start: 8012, name: "compute_single_polynomial_commitment" }, { start: 8827, name: "compute_single_polynomial_commitment_checked" }, { start: 9138, name: "compute_multiple_polynomial_commitment" }, { start: 9375, name: "compute_challenge" }, { start: 9585, name: "single_polynomial_payload" }, { start: 9784, name: "multiple_polynomial_payload" }, { start: 9970, name: "single_polynomial_payload_checked" }, { start: 10185, name: "multiple_polynomial_payload_checked" }, { start: 10406, name: "compute_dkg_pk_commitment" }, { start: 10733, name: "compute_threshold_pk_commitment" }, { start: 11138, name: "compute_multiple_polynomial_commitment_checked" }, { start: 11750, name: "compute_threshold_pk_commitment_checked" }, { start: 12008, name: "compute_share_computation_sk_commitment" }, { start: 12516, name: "compute_share_computation_sk_commitment_checked" }, { start: 12795, name: "compute_share_computation_e_sm_commitment" }, { start: 13067, name: "compute_share_encryption_commitment_from_message" }, { start: 13647, name: "compute_share_encryption_commitment_from_message_checked" }, { start: 13931, name: "compute_aggregated_shares_commitment" }, { start: 14512, name: "compute_threshold_decryption_share_commitment" }, { start: 15336, name: "compute_threshold_decryption_share_commitment_checked" }, { start: 15876, name: "compute_share_computation_e_sm_commitment_checked" }, { start: 16182, name: "compute_pk_aggregation_commitment" }, { start: 16571, name: "compute_recursive_aggregation_commitment" }, { start: 16686, name: "compute_vk_hash" }, { start: 17169, name: "compute_aggregated_shares_commitment_checked" }, { start: 17843, name: "compute_ciphertext_commitment_checked" }, { start: 18325, name: "compute_ciphertext_commitment" }, { start: 18724, name: "compute_threshold_pk_challenge" }, { start: 18866, name: "compute_share_encryption_challenge" }, { start: 19023, name: "compute_threshold_share_decryption_challenge" }, { start: 19183, name: "compute_user_data_encryption_ct0_challenge" }, { start: 19344, name: "compute_user_data_encryption_ct1_challenge" }] }, "95": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Helper functions for circuit construction and cryptographic operations.\nuse crate::math::polynomial::Polynomial;\nuse crate::math::safe::SafeSponge;\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by pack/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout<let BIT: u32>() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n // `group == 1` packs one value per carrier: it saves no sponge absorptions at all while still\n // charging the range checks that make packing injective, so it is always a loss. Measured at\n // BIT=143: +82% gates against absorbing directly. Reject it rather than pay for nothing.\n assert(group >= 2);\n (nibble_bits, group)\n}\n\n/// Like [`pack`], but asserts every digit fits its slot.\n///\n/// ## Why\n/// `pack` builds each carrier as a base-`radix` number, `acc = acc * radix + (v + base)`. That\n/// representation is unique only while every digit stays below `radix`. An unbounded value can\n/// overflow its slot and cancel against the next, so one commitment gains a second opening and a\n/// prover can choose which coefficients it opens to.\n///\n/// `digit < radix` is exactly `digit.assert_max_bit_size::<nibble_bits + 4>()`, and because\n/// `assert_max_bit_size` also forces `digit >= 0`, a single assert gives the whole condition.\n///\n/// ## When to use it\n/// Use this where a circuit **opens** a commitment it did not create. The creating circuit's own\n/// range checks already keep its digits in slot, so asserting the same here forces the opened\n/// coefficients to equal the committed ones \u2014 injectivity transfers the upstream bound without\n/// repeating it. One assert costs about half a two-sided `range_check_2bounds`.\n///\n/// It does **not** replace a bound the protocol requires in its own right, and it gives injectivity,\n/// not canonicality: it pins the opening, not a unique representative modulo `q`. A value that no\n/// upstream circuit bounded still needs its own check (see C1 `pk0` and C5 `pk0_agg`).\n///\n/// ## Compatibility\n/// Adding asserts does not change the packed value, so a commitment created with [`pack`] and\n/// opened with `pack_checked` agree. Adoption is per circuit and needs no commitment change.\npub fn pack_checked<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field);\n let radix = 2.pow_32((nibble_bits + 4) as Field);\n\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n for chunk in 0..num_chunks {\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n let digit = v + base;\n // digit < radix = 2^(nibble_bits + 4): the injectivity condition.\n digit.assert_max_bit_size::<((BIT + 3) / 4) * 4 + 4>();\n acc = acc * radix + digit;\n }\n\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Like [`flatten`], but packs with [`pack_checked`]. Use where a circuit opens a commitment it did\n/// not create.\npub fn flatten_checked<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n let packed = pack_checked::<A, BIT>(poly[j].coefficients);\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n inputs\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `pack::<A, BIT>` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::<BIT>()` and must match what `pack` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::<A, BIT>(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `[Field]` vector of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::<BIT>()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `pack` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::<BIT>()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `[Field]` vector where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Computes a cryptographic hash using the SAFE (Sponge API for Field Elements) protocol.\n///\n/// This is a convenience wrapper around the SAFE sponge API that handles the full\n/// lifecycle: initialization, absorption, squeezing, and finalization. It's designed\n/// for use in Fiat-Shamir challenge generation and commitment schemes within zero-knowledge circuits.\n///\n/// # Arguments\n/// * `domain_separator` - A 64-byte domain separator used to differentiate between\n/// different protocol instances and prevent cross-protocol attacks.\n/// * `inputs` - Vector of field elements to be absorbed into the sponge.\n/// * `io_pattern` - A 2-element array encoding the I/O pattern:\n/// - `io_pattern[0]`: Encoded ABSORB operation (MSB=1, lower 31 bits = length)\n/// - `io_pattern[1]`: Encoded SQUEEZE operation (MSB=0, lower 31 bits = length)\n///\n/// # Returns\n/// A vector of field elements squeezed from the sponge, with length determined by\n/// the SQUEEZE operation in the IO pattern.\n/// Proves `0 <= v < upper` using two one-sided bit-size checks.\n///\n/// `assert_max_bit_size` is one-sided: it forces a small **non-negative** field element. So bounding\n/// `v` gives `v >= 0`, and bounding `upper - 1 - v` gives `v <= upper - 1`. The pair composes into a\n/// two-sided interval without a comparison operator.\n///\n/// `BIT` must cover `upper`; the caller supplies it from the generated config.\npub fn assert_in_range<let BIT: u32>(v: Field, upper: Field) {\n v.assert_max_bit_size::<BIT>();\n (upper - 1 - v).assert_max_bit_size::<BIT>();\n}\n\npub fn compute_safe(domain_separator: [u8; 64], inputs: [Field], io_pattern: [u32; 2]) -> [Field] {\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let digests = sponge.squeeze();\n sponge.finish();\n\n digests\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert(result[0] == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result[1] == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result[2] == 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert(result[0] == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result[1] == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result[2] == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result[3] == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result[4] == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result[5] == 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result[0] == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result[1] == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result[2] == 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n\n#[test]\nfn test_safe_hashing_with_safe_helper() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let digests1 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests1.len() == 1);\n assert(digests1[0] != 0);\n\n // Test determinism\n let digests2 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests2.len() == 1);\n assert(digests2[0] != 0);\n assert(digests2[0] == digests1[0]);\n}\n\n#[test]\nfn test_pack() {\n // Test pack function directly with small values\n let values = [1, 2, 3, 4];\n let packed = pack::<4, 4>(values);\n\n // With BIT=4, nibble_bits=4, group should be floor(254/(4+4)) = 31\n // So all 4 values should fit in one carrier\n assert(packed.len() >= 1);\n\n // Test with negative values\n let values_neg = [-1, 2, -3, 4];\n let packed_neg = pack::<4, 4>(values_neg);\n assert(packed_neg.len() >= 1);\n}\n\n#[test]\nfn test_pack_single_value() {\n // Test packing a single value\n let values = [42];\n let packed = pack::<1, 8>(values);\n assert(packed.len() == 1);\n assert(packed[0] != 0);\n}\n\n#[test]\nfn test_pack_determinism() {\n // Test that packing is deterministic\n let values = [10, 20, 30];\n let packed1 = pack::<3, 8>(values);\n let packed2 = pack::<3, 8>(values);\n\n assert(packed1.len() == packed2.len());\n for i in 0..packed1.len() {\n assert(packed1[i] == packed2[i]);\n }\n}\n\n/// `pack_checked` must agree with `pack` for in-slot values. The two carry duplicate layout\n/// arithmetic, so if one is changed without the other, a commitment created by a circuit on `pack`\n/// stops matching one opened by a circuit on `pack_checked`. This pins that.\n#[test]\nfn test_pack_checked_matches_pack() {\n // Mixed signs, and values at the edge of the centred window for BIT = 35 (slot = 2^40).\n let vals: [Field; 7] = [0, 1, -1, 34359701504, -34359701504, 12345, -6789];\n let plain = pack::<7, 35>(vals);\n let checked = pack_checked::<7, 35>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n\n/// Same, at a width whose chunking leaves a partial final carrier (BIT = 57 -> group 3, 7 values).\n#[test]\nfn test_pack_checked_matches_pack_partial_chunk() {\n let vals: [Field; 7] = [5, -5, 72057594049265664, -72057594049265664, 1, 0, -1];\n let plain = pack::<7, 57>(vals);\n let checked = pack_checked::<7, 57>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/helpers.nr", function_locations: [{ start: 1374, name: "packing_layout" }, { start: 3703, name: "pack_checked" }, { start: 4808, name: "flatten_checked" }, { start: 6096, name: "flatten" }, { start: 7946, name: "pack" }, { start: 10581, name: "assert_in_range" }, { start: 10770, name: "compute_safe" }, { start: 10968, name: "test_flatten" }, { start: 11911, name: "test_flatten_big" }, { start: 14812, name: "test_flatten_small" }, { start: 15639, name: "test_safe_hashing_with_safe_helper" }, { start: 16485, name: "test_pack" }, { start: 16955, name: "test_pack_single_value" }, { start: 17151, name: "test_pack_determinism" }, { start: 17749, name: "test_pack_checked_matches_pack" }, { start: 18287, name: "test_pack_checked_matches_pack_partial_chunk" }] }, "100": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Multiplies lhs and rhs via u128 arithmetic, returning (quotient, remainder).\n///\n/// Safe when lhs, rhs < 2^62: product < 2^124, fits in u128 without wrapping.\n/// Prefer this over `__mul_with_quotient` when inputs are known to be < 2^62 (i.e. when\n/// the modulus is < 2^62), as it avoids silent Field-prime wraparound.\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_with_quotient_u128(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n let product = lhs as u128 * rhs as u128; // safe: inputs < 2^62, product < 2^124\n let q = m as u128;\n ((product / q) as Field, (product % q) as Field)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/modulo/unconstrained_U128.nr", function_locations: [{ start: 1160, name: "__compute_mod_reduction" }, { start: 1817, name: "__neg" }, { start: 3254, name: "__sub_with_underflow" }, { start: 5015, name: "__mul_with_quotient" }, { start: 5946, name: "__mul_with_quotient_u128" }, { start: 6810, name: "__inv_mod" }, { start: 7427, name: "__div_mod" }, { start: 8034, name: "__pow_mod" }, { start: 8895, name: "__mul_mod" }, { start: 9402, name: "test_compute_mod_reduction_simple" }, { start: 9712, name: "test_compute_mod_reduction_exact_multiple" }, { start: 9994, name: "test_compute_mod_reduction_large_value" }, { start: 10301, name: "test_compute_mod_reduction_smaller_than_modulus" }, { start: 10548, name: "test_neg_zero" }, { start: 10738, name: "test_neg_non_zero" }, { start: 10922, name: "test_neg_large_value" }, { start: 11125, name: "test_neg_verification" }, { start: 11555, name: "test_sub_with_underflow_no_underflow" }, { start: 11820, name: "test_sub_with_underflow_with_underflow" }, { start: 12098, name: "test_sub_with_underflow_equal_values" }, { start: 12337, name: "test_mul_with_quotient_simple" }, { start: 12677, name: "test_mul_with_quotient_with_reduction" }, { start: 13001, name: "test_mul_with_quotient_exact_multiple" }, { start: 13317, name: "test_mul_with_quotient_verification" }, { start: 13707, name: "test_mul_mod_simple" }, { start: 13919, name: "test_mul_mod_with_reduction" }, { start: 14141, name: "test_mul_mod_exact_multiple" }, { start: 14354, name: "test_mul_mod_with_zero" }, { start: 14531, name: "test_mul_mod_commutative" }, { start: 14912, name: "test_pow_mod_simple" }, { start: 15119, name: "test_pow_mod_with_reduction" }, { start: 15332, name: "test_pow_mod_exponent_one" }, { start: 15529, name: "test_pow_mod_exponent_zero" }, { start: 15722, name: "test_pow_mod_base_zero" }, { start: 15920, name: "test_pow_mod_large_exponent" }, { start: 16142, name: "test_pow_mod_fermat_little_theorem" }, { start: 16429, name: "test_inv_mod_simple" }, { start: 16808, name: "test_inv_mod_larger_prime" }, { start: 17108, name: "test_inv_mod_another_prime" }, { start: 17413, name: "test_inv_mod_inverse_of_inverse" }, { start: 17761, name: "test_div_mod_simple" }, { start: 18101, name: "test_div_mod_with_inverse" }, { start: 18514, name: "test_div_mod_verification" }, { start: 18882, name: "test_div_mod_larger_values" }, { start: 19396, name: "test_div_mod_by_one" }, { start: 19710, name: "test_all_operations_consistency" }] }, "102": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse super::modulo::U128::ModU128;\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial<let N: u32> {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl<let N: u32> Polynomial<N> {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n /// Inner product of the coefficients with `k`, in the same index order.\n ///\n /// Paired with [`negacyclic_kernel`] this evaluates a product modulo `X^N + 1` without the\n /// product itself entering the witness.\n pub fn dot(self, k: [Field; N]) -> Field {\n let mut out: Field = 0;\n for j in 0..N {\n out += self.coefficients[j] * k[j];\n }\n out\n }\n\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point with modular reduction.\n ///\n /// This function computes `P(x) mod q` using Horner's method with intermediate\n /// modular reductions to prevent overflow. The result is guaranteed to be in\n /// the range `[0, q)`.\n ///\n /// The function performs modular reduction after each multiplication and addition\n /// to ensure the accumulator always remains in the range `[0, q)`, preventing\n /// any potential overflow issues.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial\n /// * `q` - The modular arithmetic context containing the modulus\n ///\n /// # Returns\n /// The value `P(x) mod q` in the range `[0, q)`\n pub fn eval_mod(self, x: Field, q: ModU128) -> Field {\n let mut acc = self.coefficients[0];\n let len = self.coefficients.len();\n\n for i in 1..len {\n acc = q.mul_mod(acc, x);\n acc = q.add(acc, self.coefficients[i]);\n }\n\n acc\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds.\n ///\n /// This function constrains all polynomial coefficients to be in the range [-lower_bound, upper_bound],\n /// where `lower_bound` is a non-negative magnitude.\n /// It uses a shifting technique to handle negative numbers efficiently:\n /// 1. Shifts each coefficient by adding `lower_bound`: c' = c + lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound + lower_bound] using bit-size assertions\n /// 3. This ensures original coefficients are in [-lower_bound, upper_bound]\n ///\n /// The function uses two bit-size checks per coefficient to ensure the value is within bounds:\n /// - `shifted_coefficient.assert_max_bit_size::<BIT + 1>()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>()` ensures c' <= range_size\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - Non-negative magnitude of the negative bound\n /// Coefficients must satisfy: -lower_bound <= c <= upper_bound\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length of the total range `upper_bound + lower_bound`\n /// (choose `BIT` so `upper_bound + lower_bound < 2^BIT`). Since all checked\n /// values lie in `[0, upper_bound + lower_bound]`, they cannot exceed `BIT + 1` bits.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the specified bounds.\n pub fn range_check_2bounds<let BIT: u32>(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::<BIT + 1>();\n (range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, upper_bound).\n ///\n /// This function constrains all polynomial coefficients to be non-negative and\n /// strictly less than `upper_bound`. It uses bit-size assertions to verify that\n /// coefficients are in the valid range.\n ///\n /// The function performs two checks per coefficient:\n /// 1. `coeff.assert_max_bit_size::<BIT>()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::<BIT>()` ensures `coeff < upper_bound`\n ///\n /// # Arguments\n /// * `upper_bound` - The exclusive upper bound for coefficient range checking.\n /// Coefficients must satisfy: `0 <= c < upper_bound`\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Must satisfy `upper_bound <= 2^BIT` for\n /// the range check to work correctly.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, upper_bound)`.\n pub fn range_check_standard<let BIT: u32>(self, upper_bound: Field) {\n for i in 0..self.coefficients.len() {\n let coeff = self.coefficients[i];\n // Check coeff >= 0 and coeff < 2^BIT\n coeff.assert_max_bit_size::<BIT>();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::<BIT>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, 2^BIT).\n ///\n /// This is a specialized range check for coefficients that must be non-negative\n /// and less than a power of two. It's more efficient than `range_check_standard`\n /// when the upper bound is exactly `2^BIT` because it only needs a single\n /// bit-size assertion per coefficient.\n ///\n /// The function verifies that each coefficient satisfies:\n /// - `coeff >= 0` (implicit from bit-size check)\n /// - `coeff < 2^BIT` (enforced by `assert_max_bit_size::<BIT>()`)\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Coefficients must satisfy: `0 <= c < 2^BIT`\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, 2^BIT)`.\n pub fn range_check_power_of_two<let BIT: u32>(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::<BIT>();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert(result == 0);\n}\n\n/// Evaluation kernel for `u` modulo `X^N + 1`: `out[j]` is `(X^(N-1-j) * u mod X^N + 1)(x)`.\n///\n/// `a.dot(negacyclic_kernel(u, x))` then equals `(a * u mod X^N + 1)(x)` without the prover\n/// supplying the product, so no product witness has to be bound or range-checked.\npub fn negacyclic_kernel<let N: u32>(u: Polynomial<N>, x: Field) -> [Field; N] {\n assert(N > 0);\n let phi = x.pow_32(N as Field) + 1;\n let mut out = [0; N];\n out[N - 1] = u.eval(x);\n for j in 1..N {\n out[N - 1 - j] = x * out[N - j] - phi * u.coefficients[j - 1];\n }\n out\n}\n\n#[test]\nfn test_negacyclic_kernel_matches_reduced_product() {\n let a = Polynomial::new([4, 3, 2, 1]);\n let u = Polynomial::new([-1, 0, 1, -1]);\n\n // Schoolbook product, then reduced by hand with X^4 = -1.\n let mut prod = [0; 7];\n for i in 0..4 {\n for j in 0..4 {\n prod[i + j] += a.coefficients[i] * u.coefficients[j];\n }\n }\n let reduced = Polynomial::new([prod[3], prod[4] - prod[0], prod[5] - prod[1], prod[6] - prod[2]]);\n\n let points: [Field; 4] = [0, 1, 2, 17];\n for j in 0..4 {\n let x = points[j];\n assert(a.dot(negacyclic_kernel(u, x)) == reduced.eval(x));\n }\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_polynomial_add() {\n let coeffs1 = [1, 2, 3]; // 1x^2 + 2x + 3\n let coeffs2 = [4, 5, 6]; // 4x^2 + 5x + 6\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.add(poly2);\n\n // Expected: (1+4)x^2 + (2+5)x + (3+6) = 5x^2 + 7x + 9\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 7);\n assert(result.coefficients[2] == 9);\n}\n\n#[test]\nfn test_polynomial_sub() {\n let coeffs1 = [5, 7, 9]; // 5x^2 + 7x + 9\n let coeffs2 = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.sub(poly2);\n\n // Expected: (5-1)x^2 + (7-2)x + (9-3) = 4x^2 + 5x + 6\n assert(result.coefficients[0] == 4);\n assert(result.coefficients[1] == 5);\n assert(result.coefficients[2] == 6);\n}\n\n#[test]\nfn test_polynomial_mul_scalar() {\n let coeffs = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n let scalar = 5;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 5x^2 + 10x + 15\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 10);\n assert(result.coefficients[2] == 15);\n}\n\n#[test]\nfn test_polynomial_mul_scalar_zero() {\n let coeffs = [1, 2, 3];\n let poly = Polynomial::new(coeffs);\n let scalar = 0;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 0x^2 + 0x + 0 = 0\n assert(result.coefficients[0] == 0);\n assert(result.coefficients[1] == 0);\n assert(result.coefficients[2] == 0);\n}\n\n#[test]\nfn test_eval_mod_simple() {\n // Test without initial reduction - simple case\n // p(x) = x + 1 at x=5od 7\n // Expected: (5 + 1) mod 7 = 6\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 1]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 6);\n\n // Test: p(x) = 2x + 3 at x=5od 7\n // Expected: (10 + 3) mod 7 = 13 mod 7 = 6\n let poly2 = Polynomial::new([2, 3]);\n let result2 = poly2.eval_mod(5, q);\n assert(result2 == 6);\n}\n\n#[test]\nfn test_eval_mod() {\n // Test 1: Simple polynomial x^2 + 2x + 3 at x=5od 7\n // Expected: (25 + 10 + 3) mod 7 = 38 mod 7 = 3\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 2, 3]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 3);\n\n // Test 2: Higher degree polynomialod small prime\n // p(x) = x^3 + x^2 + x + 1 at x=2od 11\n // Expected: (8 + 4 + 2 + 1) mod 11 = 15 mod 11 = 4\n let q = ModU128::new(11);\n\n let poly2 = Polynomial::new([1, 1, 1, 1]);\n let result2 = poly2.eval_mod(2, q);\n assert(result2 == 4);\n\n // Test 3: Polynomial with larger coefficients\n // p(x) = 100x^2 + 50x + 25 at x=10od 73\n // Expected: (10000 + 500 + 25) mod 73 = 10525 mod 73 = 13\n let q = ModU128::new(73);\n\n let poly3 = Polynomial::new([100, 50, 25]);\n let result3 = poly3.eval_mod(10, q);\n assert(result3 == 13);\n\n // Test 4: Result should be less than modulus\n let poly4 = Polynomial::new([5, 3, 7]);\n let q = ModU128::new(17);\n let result4 = poly4.eval_mod(4, q);\n assert(result4 as u128 < q.get_mod_field() as u128);\n\n // Test 5: Compare with regular eval for small values\n let poly5 = Polynomial::new([1, 2, 1]);\n let x = 3;\n let q = ModU128::new(1000);\n let result5 = poly5.eval_mod(x, q);\n let expected5 = poly5.eval(x);\n assert(result5 == expected5);\n\n // Test 6: Zero polynomial\n let poly6 = Polynomial::new([0, 0, 0]);\n let q = ModU128::new(13);\n let result6 = poly6.eval_mod(100, q);\n assert(result6 == 0);\n}\n\n#[test]\nfn test_large_party_ids_scenario() {\n // Simulating party IDs in range [1, 100]\n let party_id_1 = 42;\n let party_id_2 = 73;\n let m = ModU128::new(288230376151711717); // ~58 bits\n\n // Operations that would be used in Lagrange coefficients\n let product = m.mul_mod(party_id_1, party_id_2);\n let diff = m.sub(party_id_2, party_id_1);\n\n assert(product == 3066);\n assert(diff == 31);\n}\n\n#[test]\nfn test_eval_vs_eval_mod() {\n // Compare eval and eval_mod for small values where no reduction should occur\n let poly = Polynomial::new([1, 2, 3]);\n let x = 2;\n let q = ModU128::new(1000); // Large enough that no reduction happens\n\n let result_normal = poly.eval(x);\n let result_mod = poly.eval_mod(x, q);\n\n // They should be equal: (1)*2 + 2)*2 + 3 = (2+2)*2 + 3 = 4*2 + 3 = 11\n assert(result_normal == 11);\n assert(result_mod == 11);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/polynomial.nr", function_locations: [{ start: 1261, name: "Polynomial<N>::new" }, { start: 1555, name: "Polynomial<N>::add" }, { start: 2008, name: "Polynomial<N>::sub" }, { start: 2481, name: "Polynomial<N>::mul_scalar" }, { start: 3426, name: "Polynomial<N>::dot" }, { start: 3602, name: "Polynomial<N>::eval" }, { start: 4576, name: "Polynomial<N>::eval_mod" }, { start: 6506, name: "Polynomial<N>::range_check_2bounds" }, { start: 7992, name: "Polynomial<N>::range_check_standard" }, { start: 9247, name: "Polynomial<N>::range_check_power_of_two" }, { start: 9416, name: "test_polynomial_eval_zero" }, { start: 9976, name: "negacyclic_kernel" }, { start: 10259, name: "test_negacyclic_kernel_matches_reduced_product" }, { start: 10873, name: "test_polynomial_bounds" }, { start: 11156, name: "test_polynomial_out_of_bounds_coefficients" }, { start: 11411, name: "test_polynomial_add" }, { start: 11844, name: "test_polynomial_sub" }, { start: 12284, name: "test_polynomial_mul_scalar" }, { start: 12641, name: "test_polynomial_mul_scalar_zero" }, { start: 12970, name: "test_eval_mod_simple" }, { start: 13450, name: "test_eval_mod" }, { start: 15008, name: "test_large_party_ids_scenario" }, { start: 15418, name: "test_eval_vs_eval_mod" }] }, "104": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\nuse poseidon::poseidon2_permutation;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// "SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge<let L: u32> {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl<let L: u32> SafeSponge<L> {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge<L> {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: [Field]) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, "Expected ABSORB operation");\n assert(expected_length == length, "Length mismatch");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input[i];\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> [Field] {\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, "Expected SQUEEZE operation");\n\n let mut output: [Field] = [].as_vector();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won\'t execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output = output.push_back(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, "IO pattern not completed");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge\'s usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag<let L: u32>(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Buffer is 256 bytes: max 192 bytes for IO pattern (48 words) + 64 bytes for domain separator.\n // Note: We must use a fixed-size array because Noir\'s keccak256 requires [u8; N], not [u8].\n let max_io_pattern_bytes: u32 = 192; // 256 - 64 (domain separator)\n let io_pattern_bytes = word_count * 4;\n assert(\n io_pattern_bytes <= max_io_pattern_bytes,\n "IO pattern too large: max 48 aggregated words supported",\n );\n\n let mut input_bytes = [0u8; 256];\n let mut byte_count: u32 = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n // Note: Noir requires compile-time loop bounds, so we iterate over L (the array size)\n // instead of word_count (runtime value). The condition `i < word_count` ensures we only\n // process valid encoded words. This is safe because word_count <= L always holds\n // (we can have at most L encoded words from L input operations).\n for i in 0..L {\n if i < word_count {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append full 64-byte domain separator.\n for i in 0..64 {\n input_bytes[byte_count] = domain_separator[i];\n byte_count += 1;\n }\n\n // Step 3: Hash with Keccak-256 and truncate to 128 bits.\n // Note: The SAFE spec uses SHA3-256, but we use Keccak-256 for Noir compatibility.\n // Keccak-256 differs from SHA3-256 in padding, but both provide equivalent security.\n let hash_bytes = keccak256(input_bytes, byte_count);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = [123].as_vector();\n let right = [456].as_vector();\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = [10, 20, 30].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = [1, 2, 3].as_vector();\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1[0] != output2[0]); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output[0] != 0);\n assert(output[1] != 0);\n assert(output[0] != output[1]); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb([].as_vector());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println("=== SAFE Tag Computation Debug Test ===");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f"Testing pattern: {io_pattern}");\n println(\n f"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)",\n );\n println(\n f"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]",\n );\n println("");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f"=== Expected Rust Output ===");\n println("Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))");\n println("Domain separator: 0x41424344...");\n println("Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a");\n println("");\n\n println(f"=== Noir Output ===");\n println(f"Tag: {tag}");\n println("");\n\n println("Compare the tag values above with Rust script!");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Consecutive ABSORB operations should aggregate to the same tag");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive ABSORB operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive ABSORB Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n "Consecutive SQUEEZE operations should aggregate to the same tag",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive SQUEEZE operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive SQUEEZE Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Mixed consecutive operations should aggregate to the same tag");\n\n println("=== Mixed Consecutive Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]",\n );\n println(\n f" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))",\n );\n println(f"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]");\n println(f" (ABSORB(2), SQUEEZE(2), ABSORB(1))");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n}\n\n#[test]\nfn test_large_io_pattern() {\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Create pattern with 48 alternating ABSORB(1) and SQUEEZE(1) operations\n // This is the maximum supported (48 words * 4 bytes = 192 bytes, leaving 64 for domain separator)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1; // ABSORB(1)\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1; // SQUEEZE(1)\n }\n }\n\n let tag = compute_tag(io_pattern, domain_separator);\n assert(tag != 0);\n}\n\n#[test]\nfn test_domain_separator_not_truncated() {\n // This test verifies that the domain separator is always included in the tag computation,\n // even for large IO patterns. If the domain separator were truncated, different domain\n // separators would produce the same tag for large patterns.\n\n let domain_separator_a = [\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41,\n ]; // All \'A\'s\n\n let domain_separator_b = [\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42,\n ]; // All \'B\'s\n\n // Create pattern with 48 alternating operations (max supported: 192 bytes of IO pattern)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1;\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1;\n }\n }\n\n let tag_a = compute_tag(io_pattern, domain_separator_a);\n let tag_b = compute_tag(io_pattern, domain_separator_b);\n\n // Tags MUST be different because domain separators are different.\n // If they were the same, it would mean the domain separator was truncated/ignored.\n assert(tag_a != tag_b, "Domain separator must affect tag even for large IO patterns");\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/safe.nr", function_locations: [{ start: 4164, name: "SafeSponge<L>::start" }, { start: 5046, name: "SafeSponge<L>::absorb" }, { start: 6826, name: "SafeSponge<L>::squeeze" }, { start: 8494, name: "SafeSponge<L>::finish" }, { start: 9156, name: "SafeSponge<L>::permute" }, { start: 9830, name: "compute_tag" }, { start: 14128, name: "test_safe_hashing" }, { start: 15104, name: "test_merkle_node" }, { start: 16281, name: "test_commitment_scheme" }, { start: 17357, name: "test_domain_separation" }, { start: 18710, name: "test_multiple_squeeze" }, { start: 19639, name: "test_zero_length_operations" }, { start: 20415, name: "test_tag_computation" }, { start: 21477, name: "test_tag_computation_debug" }, { start: 22681, name: "test_consecutive_absorb_aggregation" }, { start: 24750, name: "test_consecutive_squeeze_aggregation" }, { start: 26760, name: "test_mixed_consecutive_aggregation" }, { start: 28520, name: "test_large_io_pattern" }, { start: 29333, name: "test_domain_separator_not_truncated" }] }, "163": { source: "// Instantiations of Poseidon permutation for the prime field of the same order as BN254\nuse crate::poseidon::bn254::consts;\nuse crate::poseidon::permute;\n\n#[field(bn254)]\npub fn x5_2(mut state: [Field; 2]) -> [Field; 2] {\n state = permute(consts::x5_2_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_3(mut state: [Field; 3]) -> [Field; 3] {\n state = permute(consts::x5_3_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_4(mut state: [Field; 4]) -> [Field; 4] {\n state = permute(consts::x5_4_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_5(mut state: [Field; 5]) -> [Field; 5] {\n state = permute(consts::x5_5_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_6(mut state: [Field; 6]) -> [Field; 6] {\n state = permute(consts::x5_6_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_7(mut state: [Field; 7]) -> [Field; 7] {\n state = permute(consts::x5_7_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_8(mut state: [Field; 8]) -> [Field; 8] {\n state = permute(consts::x5_8_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_9(mut state: [Field; 9]) -> [Field; 9] {\n state = permute(consts::x5_9_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_10(mut state: [Field; 10]) -> [Field; 10] {\n state = permute(consts::x5_10_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_11(mut state: [Field; 11]) -> [Field; 11] {\n state = permute(consts::x5_11_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_12(mut state: [Field; 12]) -> [Field; 12] {\n state = permute(consts::x5_12_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_13(mut state: [Field; 13]) -> [Field; 13] {\n state = permute(consts::x5_13_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_14(mut state: [Field; 14]) -> [Field; 14] {\n state = permute(consts::x5_14_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_15(mut state: [Field; 15]) -> [Field; 15] {\n state = permute(consts::x5_15_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_16(mut state: [Field; 16]) -> [Field; 16] {\n state = permute(consts::x5_16_config(), state);\n\n state\n}\n\n#[field(bn254)]\npub fn x5_17(mut state: [Field; 17]) -> [Field; 17] {\n state = permute(consts::x5_17_config(), state);\n\n state\n}\n", path: "/Users/ctrlc03/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon/bn254/perm.nr", function_locations: [{ start: 221, name: "x5_2" }, { start: 353, name: "x5_3" }, { start: 485, name: "x5_4" }, { start: 617, name: "x5_5" }, { start: 749, name: "x5_6" }, { start: 881, name: "x5_7" }, { start: 1013, name: "x5_8" }, { start: 1145, name: "x5_9" }, { start: 1280, name: "x5_10" }, { start: 1416, name: "x5_11" }, { start: 1552, name: "x5_12" }, { start: 1688, name: "x5_13" }, { start: 1824, name: "x5_14" }, { start: 1960, name: "x5_15" }, { start: 2096, name: "x5_16" }, { start: 2232, name: "x5_17" }] }, "164": { source: "// Instantiations of Poseidon constants, permutations and sponge for prime field of the same order as BN254\npub mod perm;\npub mod consts;\n\nuse crate::poseidon::absorb;\n\n// Variable-length Poseidon-128 sponge as suggested in second bullet point of section 3 of https://eprint.iacr.org/2019/458.pdf\n#[field(bn254)]\npub fn sponge<let N: u32>(msg: [Field; N]) -> Field {\n absorb(consts::x5_5_config(), [0; 5], 4, 1, msg)[1]\n}\n\n// Creates state array with input at positions [1..N+1], then applies permutation\nfn hash_internal<let N: u32, let STATE_SIZE: u32>(\n input: [Field; N],\n perm_fn: fn([Field; STATE_SIZE]) -> [Field; STATE_SIZE],\n) -> Field {\n let mut state = [0; STATE_SIZE];\n for i in 0..N {\n state[i + 1] = input[i];\n }\n perm_fn(state)[0]\n}\n\n// Various instances of the Poseidon hash function\n// Consistent with Circom's implementation\n#[no_predicates]\npub fn hash_1(input: [Field; 1]) -> Field {\n hash_internal(input, perm::x5_2)\n}\n\n#[no_predicates]\npub fn hash_2(input: [Field; 2]) -> Field {\n hash_internal(input, perm::x5_3)\n}\n\n#[no_predicates]\npub fn hash_3(input: [Field; 3]) -> Field {\n hash_internal(input, perm::x5_4)\n}\n\n#[no_predicates]\npub fn hash_4(input: [Field; 4]) -> Field {\n hash_internal(input, perm::x5_5)\n}\n\n#[no_predicates]\npub fn hash_5(input: [Field; 5]) -> Field {\n hash_internal(input, perm::x5_6)\n}\n\n#[no_predicates]\npub fn hash_6(input: [Field; 6]) -> Field {\n hash_internal(input, perm::x5_7)\n}\n\n#[no_predicates]\npub fn hash_7(input: [Field; 7]) -> Field {\n hash_internal(input, perm::x5_8)\n}\n\n#[no_predicates]\npub fn hash_8(input: [Field; 8]) -> Field {\n hash_internal(input, perm::x5_9)\n}\n\n#[no_predicates]\npub fn hash_9(input: [Field; 9]) -> Field {\n hash_internal(input, perm::x5_10)\n}\n\n#[no_predicates]\npub fn hash_10(input: [Field; 10]) -> Field {\n hash_internal(input, perm::x5_11)\n}\n\n#[no_predicates]\npub fn hash_11(input: [Field; 11]) -> Field {\n hash_internal(input, perm::x5_12)\n}\n\n#[no_predicates]\npub fn hash_12(input: [Field; 12]) -> Field {\n hash_internal(input, perm::x5_13)\n}\n\n#[no_predicates]\npub fn hash_13(input: [Field; 13]) -> Field {\n hash_internal(input, perm::x5_14)\n}\n\n#[no_predicates]\npub fn hash_14(input: [Field; 14]) -> Field {\n hash_internal(input, perm::x5_15)\n}\n\n#[no_predicates]\npub fn hash_15(input: [Field; 15]) -> Field {\n hash_internal(input, perm::x5_16)\n}\n\n#[no_predicates]\npub fn hash_16(input: [Field; 16]) -> Field {\n hash_internal(input, perm::x5_17)\n}\n", path: "/Users/ctrlc03/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon/bn254.nr", function_locations: [{ start: 365, name: "sponge" }, { start: 654, name: "hash_internal" }, { start: 930, name: "hash_1" }, { start: 1031, name: "hash_2" }, { start: 1132, name: "hash_3" }, { start: 1233, name: "hash_4" }, { start: 1334, name: "hash_5" }, { start: 1435, name: "hash_6" }, { start: 1536, name: "hash_7" }, { start: 1637, name: "hash_8" }, { start: 1738, name: "hash_9" }, { start: 1842, name: "hash_10" }, { start: 1946, name: "hash_11" }, { start: 2050, name: "hash_12" }, { start: 2154, name: "hash_13" }, { start: 2258, name: "hash_14" }, { start: 2362, name: "hash_15" }, { start: 2466, name: "hash_16" }] }, "165": { source: "pub mod bn254; // Instantiations of Poseidon for prime field of the same order as BN254\nuse std::default::Default;\nuse std::hash::Hasher;\n\n// A config struct defining the parameters of the Poseidon instance to use.\n//\n// A thorough writeup of this method (along with an unoptimized method) can be found at: https://spec.filecoin.io/algorithms/crypto/poseidon/\npub struct PoseidonConfig<let T: u32, let N: u32, let X: u32> {\n // State width, should be equal to `T`\n t: Field,\n // Number of full rounds. should be even\n rf: u8,\n // Number of partial rounds\n rp: u8,\n // S-box power; depends on the underlying field\n alpha: Field,\n // The round constants for the\n round_constants: [Field; N],\n // The MDS matrix for the Poseidon instance\n mds: [[Field; T]; T],\n // An MDS matrix which also applies a basis transformation which allows\n // sparse matrices to be used for the partial rounds.\n //\n // This should be applied instead of `mds` in the final full round.\n presparse_mds: [[Field; T]; T],\n // A set of sparse matrices used for MDS mixing for the partial rounds.\n sparse_mds: [Field; X],\n}\n\npub fn config<let T: u32, let N: u32, let X: u32>(\n t: Field,\n rf: u8,\n rp: u8,\n alpha: Field,\n round_constants: [Field; N],\n mds: [[Field; T]; T],\n presparse_mds: [[Field; T]; T],\n sparse_mds: [Field; X],\n) -> PoseidonConfig<T, N, X> {\n // Input checks\n assert_eq(rf & 1, 0);\n assert_eq((t as u8) * rf + rp, N as u8);\n assert_eq(t, T as Field);\n assert(alpha != 0);\n\n PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds }\n}\n\npub fn permute<let T: u32, let N: u32, let X: u32>(\n pos_conf: PoseidonConfig<T, N, X>,\n mut state: [Field; T],\n) -> [Field; T] {\n let PoseidonConfig { t, rf, rp, alpha, round_constants, mds, presparse_mds, sparse_mds } =\n pos_conf;\n for i in 0..state.len() {\n state[i] += round_constants[i];\n }\n\n for _r in 0..rf / 2 - 1 {\n state = sigma(state);\n for i in 0..T {\n state[i] += round_constants[T * (_r + 1) as u32 + i];\n }\n state = apply_matrix(mds, state);\n }\n\n state = sigma(state);\n for i in 0..T {\n state[i] += round_constants[T * (rf / 2) as u32 + i];\n }\n state = apply_matrix(presparse_mds, state);\n\n for i in 0..T {\n std::as_witness(state[i]);\n }\n\n for _r in 0..rp {\n state[0] = state[0].pow_32(alpha);\n state[0] += round_constants[(rf / 2 + 1) as u32 * T + _r as u32];\n std::as_witness(state[0]);\n {\n let mut newState0 = 0;\n for j in 0..T {\n newState0 += sparse_mds[(T * 2 - 1) * _r as u32 + j as u32] * state[j];\n }\n for k in 1..T {\n state[k] += state[0] * sparse_mds[(t * 2 - 1) as u32 * _r as u32 + T + k - 1];\n }\n state[0] = newState0;\n\n if (_r & 1 == 0) {\n for k in 1..T {\n std::as_witness(state[k]);\n }\n }\n }\n }\n\n for _r in 0..rf / 2 - 1 {\n state = sigma(state);\n for i in 0..state.len() {\n state[i] += round_constants[(rf / 2 + 1) as u32 * T + rp as u32 + (_r as u32) * T + i];\n }\n state = apply_matrix(mds, state);\n }\n\n state = sigma(state);\n state = apply_matrix(mds, state);\n state\n}\n\n// Performs matrix multiplication on a vector\nfn apply_matrix<let N: u32>(matrix: [[Field; N]; N], vec: [Field; N]) -> [Field; N] {\n let mut out = [0; N];\n\n for i in 0..N {\n for j in 0..N {\n out[i] += vec[j] * matrix[j][i];\n }\n }\n\n out\n}\n\n// Corresponding absorption.\nfn absorb<let T: u32, let N: u32, let X: u32, let O: u32>(\n pos_conf: PoseidonConfig<T, N, X>,\n // Initial state; usually [0; O]\n mut state: [Field; T],\n rate: u32,\n capacity: u32,\n msg: [Field; O], // Arbitrary length message\n) -> [Field; T] {\n assert_eq(pos_conf.t, (rate + capacity) as Field);\n\n let mut i = 0;\n\n for k in 0..msg.len() {\n // Add current block to state\n state[capacity + i] += msg[k];\n i = i + 1;\n // Enough to absorb\n if i == rate {\n state = permute(pos_conf, state);\n i = 0;\n }\n }\n // If we have one more block to permute\n if i != 0 {\n state = permute(pos_conf, state);\n }\n\n state\n}\n\nfn sigma<let O: u32>(x: [Field; O]) -> [Field; O] {\n let mut y = x;\n for i in 0..O {\n let t = y[i];\n let tt = t * t;\n let tttt = tt * tt;\n y[i] *= tttt;\n }\n y\n}\n\npub struct PoseidonHasher {\n _state: [Field],\n}\n\nimpl Hasher for PoseidonHasher {\n #[field(bn254)]\n fn finish(self) -> Field {\n let mut result = 0;\n let len = self._state.len();\n assert(len < 16);\n if len == 1 {\n result = bn254::hash_1([self._state[0]]);\n }\n if len == 2 {\n result = bn254::hash_2([self._state[0], self._state[1]]);\n }\n if len == 3 {\n result = bn254::hash_3([self._state[0], self._state[1], self._state[2]]);\n }\n if len == 4 {\n result = bn254::hash_4([self._state[0], self._state[1], self._state[2], self._state[3]]);\n }\n if len == 5 {\n result = bn254::hash_5([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n ]);\n }\n if len == 6 {\n result = bn254::hash_6([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n ]);\n }\n if len == 7 {\n result = bn254::hash_7([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n ]);\n }\n if len == 8 {\n result = bn254::hash_8([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n ]);\n }\n if len == 9 {\n result = bn254::hash_9([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n ]);\n }\n if len == 10 {\n result = bn254::hash_10([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n ]);\n }\n if len == 11 {\n result = bn254::hash_11([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n ]);\n }\n if len == 12 {\n result = bn254::hash_12([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n ]);\n }\n if len == 13 {\n result = bn254::hash_13([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n ]);\n }\n if len == 14 {\n result = bn254::hash_14([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n self._state[13],\n ]);\n }\n if len == 15 {\n result = bn254::hash_15([\n self._state[0],\n self._state[1],\n self._state[2],\n self._state[3],\n self._state[4],\n self._state[5],\n self._state[6],\n self._state[7],\n self._state[8],\n self._state[9],\n self._state[10],\n self._state[11],\n self._state[12],\n self._state[13],\n self._state[14],\n ]);\n }\n\n result\n }\n\n #[inline_always]\n fn write(&mut self, input: Field) {\n self._state = self._state.push_back(input);\n }\n}\n\nimpl Default for PoseidonHasher {\n fn default() -> Self {\n PoseidonHasher { _state: @[] }\n }\n}\n", path: "/Users/ctrlc03/nargo/github.com/noir-lang/poseidon/v0.3.0/src/poseidon/mod.nr", function_locations: [{ start: 1409, name: "config" }, { start: 1783, name: "permute" }, { start: 3549, name: "apply_matrix" }, { start: 3985, name: "absorb" }, { start: 4491, name: "sigma" }, { start: 4777, name: "<impl Hasher for PoseidonHasher>::finish" }, { start: 9874, name: "<impl Hasher for PoseidonHasher>::write" }, { start: 9996, name: "<impl Default for PoseidonHasher>::default" }] }, "171": { source: "mod tests;\nmod oracle_tests;\nmod benchmarks;\n\nuse std::hash::keccakf1600;\nuse std::runtime::is_unconstrained;\n\nglobal BLOCK_SIZE_IN_BYTES: u32 = 136; //(1600 - BITS * 2) / WORD_SIZE;\nglobal WORD_SIZE: u32 = 8; // Limbs are made up of u64s so 8 bytes each.\nglobal LIMBS_PER_BLOCK: u32 = BLOCK_SIZE_IN_BYTES / WORD_SIZE;\nglobal NUM_KECCAK_LANES: u32 = 25;\n\n#[no_predicates]\npub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32] {\n assert(N >= message_size);\n\n // Copy input to block bytes. For that we'll need at least input bytes (N)\n // but we want it to be padded to a multiple of BLOCK_SIZE_IN_BYTES.\n let mut block_bytes = [0; ((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES];\n if is_unconstrained() {\n for i in 0..message_size {\n block_bytes[i] = input[i];\n }\n } else {\n for i in 0..N {\n if i < message_size {\n block_bytes[i] = input[i];\n }\n }\n }\n\n //1. format_input_lanes and apply padding\n let max_blocks = (N + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;\n let real_max_blocks = (message_size + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;\n\n // Apply Keccak padding (0x01 after message, 0x80 at block end)\n apply_keccak_padding(&mut block_bytes, message_size, real_max_blocks);\n\n // populate a vector of 64-bit limbs from our byte array\n let mut sliced_buffer =\n [0; (((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES) / WORD_SIZE];\n for i in 0..sliced_buffer.len() {\n let limb_start = WORD_SIZE * i;\n\n let mut sliced = 0;\n let mut v = 1;\n for k in 0..WORD_SIZE {\n sliced += v * (block_bytes[limb_start + k] as Field);\n v *= 256;\n }\n\n sliced_buffer[i] = sliced as u64;\n }\n\n //2. sponge_absorb\n let mut state: [u64; NUM_KECCAK_LANES] = [0; NUM_KECCAK_LANES];\n // `real_max_blocks` is guaranteed to at least be `1`\n // We peel out the first block as to avoid a conditional inside of the loop.\n // Otherwise, a dynamic predicate can cause a blowup in a constrained runtime.\n for j in 0..LIMBS_PER_BLOCK {\n state[j] = sliced_buffer[j];\n }\n state = keccakf1600(state);\n\n let state = if is_unconstrained() {\n // When in an unconstrained runtime we can take advantage of runtime loop bounds,\n // thus allowing us to simplify the loop body.\n for i in 1..real_max_blocks {\n for j in 0..LIMBS_PER_BLOCK {\n state[j] = state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];\n }\n state = keccakf1600(state);\n }\n\n state\n } else {\n // We store the intermediate states in an array to avoid having a dynamic predicate\n // inside the loop, which can cause a blowup in a constrained runtime.\n let mut intermediate_states = [state; (N + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES + 1];\n for i in 1..max_blocks {\n let mut previous_state = intermediate_states[i - 1];\n for j in 0..LIMBS_PER_BLOCK {\n previous_state[j] = previous_state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];\n }\n intermediate_states[i] = keccakf1600(previous_state);\n }\n\n // We can then take the state as of `real_max_blocks`, ignoring later permutations.\n intermediate_states[real_max_blocks - 1]\n };\n\n //3. sponge_squeeze\n let mut result = [0; 32];\n for i in 0..4 {\n let lane = state[i] as Field;\n let lane_le: [u8; 8] = lane.to_le_bytes();\n for j in 0..8 {\n result[8 * i + j] = lane_le[j];\n }\n }\n result\n}\n\n// Apply Keccak padding to the block_bytes array\n// Append 0x01 after message, then 0x80 at end of block\n// If both padding bytes collide at the same byte, combine them as 0x81\npub(crate) fn apply_keccak_padding<let BLOCK_BYTES: u32>(\n block_bytes: &mut [u8; BLOCK_BYTES],\n message_size: u32,\n real_max_blocks: u32,\n) {\n let real_blocks_bytes = real_max_blocks * BLOCK_SIZE_IN_BYTES;\n\n block_bytes[message_size] = 0x01;\n\n if message_size == real_blocks_bytes - 1 {\n // Combine both padding bits: 0x01 | 0x80 = 0x81\n block_bytes[message_size] = 0x81;\n } else {\n block_bytes[real_blocks_bytes - 1] = 0x80;\n }\n}\n", path: "/Users/ctrlc03/nargo/github.com/noir-lang/keccak256/v0.1.2/src/keccak256.nr", function_locations: [{ start: 448, name: "keccak256" }, { start: 3998, name: "apply_keccak_padding" }] } } };
3
+
4
+ // ../../circuits/dist/insecure-64/crisp_onchain.json
5
+ var crisp_onchain_default = { noir_version: "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905", hash: "6149401998243511175", abi: { parameters: [{ name: "prev_ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "prev_ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "prev_ct_commitment", type: { kind: "field" }, visibility: "public" }, { name: "sum_ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_r0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "sum_r1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "k1", type: { kind: "struct", path: "interfold_lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "public_key_x", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "public_key_y", type: { kind: "array", length: 32, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "signature", type: { kind: "array", length: 64, type: { kind: "integer", sign: "unsigned", width: 8 } }, visibility: "private" }, { name: "digest_hi", type: { kind: "field" }, visibility: "public" }, { name: "digest_lo", type: { kind: "field" }, visibility: "public" }, { name: "slot_address", type: { kind: "field" }, visibility: "public" }, { name: "voting_power", type: { kind: "field" }, visibility: "public" }, { name: "is_first_vote", type: { kind: "boolean" }, visibility: "public" }, { name: "is_mask_vote", type: { kind: "boolean" }, visibility: "private" }, { name: "num_options", type: { kind: "integer", sign: "unsigned", width: 32 }, visibility: "public" }], return_type: { abi_type: { kind: "tuple", fields: [{ kind: "field" }, { kind: "field" }, { kind: "field" }] }, visibility: "public" }, error_types: { "819864067177566446": { error_kind: "string", string: "Field failed to decompose into specified 8 limbs" }, "6648636420357809117": { error_kind: "string", string: "the addend does not open the parent commitment" }, "12469291177396340830": { error_kind: "string", string: "call to assert_max_bit_size" }, "14401109495927734611": { error_kind: "string", string: "Field failed to decompose into specified 16 limbs" }, "14990209321349310352": { error_kind: "string", string: "attempt to add with overflow" }, "17263889889423824360": { error_kind: "string", string: "the published ciphertext is not the ballot added to the addend" } } }, bytecode: "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", debug_symbols: "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", file_map: { "12": { source: "// docs:start:ecdsa_secp256k1\n/// Verifies a ECDSA signature over the secp256k1 curve.\n/// - inputs:\n/// - x coordinate of public key as 32 bytes\n/// - y coordinate of public key as 32 bytes\n/// - the signature, as a 64 bytes array\n/// The signature internally will be represented as `(r, s)`,\n/// where `r` and `s` are fixed-sized big endian scalar values.\n/// As the `secp256k1` has a 256-bit modulus, we have a 64 byte signature\n/// while `r` and `s` will both be 32 bytes.\n/// We expect `s` to be normalized. This means given the curve's order,\n/// `s` should be less than or equal to `order / 2`.\n/// This is done to prevent malleability.\n/// For more context regarding malleability you can reference BIP 0062.\n/// - the hash of the message, as a vector of bytes\n/// - output: false for failure and true for success\npub fn verify_signature(\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n message_hash: [u8; 32],\n) -> bool\n// docs:end:ecdsa_secp256k1\n{\n _verify_signature(public_key_x, public_key_y, signature, message_hash, true)\n}\n\n#[foreign(ecdsa_secp256k1)]\nfn _verify_signature(\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n message_hash: [u8; 32],\n predicate: bool,\n) -> bool {}\n\nmod tests {\n #[test]\n fn verify() {\n let mut hashed_message: [u8; 32] = [\n 0x3a, 0x73, 0xf4, 0x12, 0x3a, 0x5c, 0xd2, 0x12, 0x1f, 0x21, 0xcd, 0x7e, 0x8d, 0x35,\n 0x88, 0x35, 0x47, 0x69, 0x49, 0xd0, 0x35, 0xd9, 0xc2, 0xda, 0x68, 0x06, 0xb4, 0x63,\n 0x3a, 0xc8, 0xc1, 0xe2,\n ];\n let pub_key_x: [u8; 32] = [\n 0xa0, 0x43, 0x4d, 0x9e, 0x47, 0xf3, 0xc8, 0x62, 0x35, 0x47, 0x7c, 0x7b, 0x1a, 0xe6,\n 0xae, 0x5d, 0x34, 0x42, 0xd4, 0x9b, 0x19, 0x43, 0xc2, 0xb7, 0x52, 0xa6, 0x8e, 0x2a,\n 0x47, 0xe2, 0x47, 0xc7,\n ];\n let pub_key_y: [u8; 32] = [\n 0x89, 0x3a, 0xba, 0x42, 0x54, 0x19, 0xbc, 0x27, 0xa3, 0xb6, 0xc7, 0xe6, 0x93, 0xa2,\n 0x4c, 0x69, 0x6f, 0x79, 0x4c, 0x2e, 0xd8, 0x77, 0xa1, 0x59, 0x3c, 0xbe, 0xe5, 0x3b,\n 0x03, 0x73, 0x68, 0xd7,\n ];\n let signature: [u8; 64] = [\n 0xe5, 0x08, 0x1c, 0x80, 0xab, 0x42, 0x7d, 0xc3, 0x70, 0x34, 0x6f, 0x4a, 0x0e, 0x31,\n 0xaa, 0x2b, 0xad, 0x8d, 0x97, 0x98, 0xc3, 0x80, 0x61, 0xdb, 0x9a, 0xe5, 0x5a, 0x4e,\n 0x8d, 0xf4, 0x54, 0xfd, 0x28, 0x11, 0x98, 0x94, 0x34, 0x4e, 0x71, 0xb7, 0x87, 0x70,\n 0xcc, 0x93, 0x1d, 0x61, 0xf4, 0x80, 0xec, 0xbb, 0x0b, 0x89, 0xd6, 0xeb, 0x69, 0x69,\n 0x01, 0x61, 0xe4, 0x9a, 0x71, 0x5f, 0xcd, 0x55,\n ];\n let valid_signature =\n super::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);\n assert(valid_signature);\n\n hashed_message[0] = 0;\n let valid_signature =\n super::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);\n assert(!valid_signature);\n }\n}\n", path: "std/ecdsa_secp256k1.nr", function_locations: [{ start: 1057, name: "verify_signature" }, { start: 1333, name: "_verify_signature" }, { start: 1377, name: "tests::verify" }] }, "16": { 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', path: "std/field/mod.nr", function_locations: [{ start: 380, name: "Field::assert_max_bit_size" }, { start: 1196, name: "Field::to_le_bits" }, { start: 2387, name: "Field::to_be_bits" }, { start: 3562, name: "Field::to_le_bytes" }, { start: 5033, name: "Field::to_be_bytes" }, { start: 5904, name: "Field::to_le_radix" }, { start: 6362, name: "Field::to_be_radix" }, { start: 7053, name: "Field::pow_32" }, { start: 7455, name: "Field::sgn0" }, { start: 7538, name: "Field::lt" }, { start: 8073, name: "Field::from_le_bytes" }, { start: 8820, name: "Field::from_be_bytes" }, { start: 9611, name: "Field::from_le_bytes_checked" }, { start: 10620, name: "Field::from_be_bytes_checked" }, { start: 11202, name: "__assert_max_bit_size" }, { start: 11330, name: "__to_le_radix" }, { start: 11458, name: "__to_be_radix" }, { start: 12179, name: "__to_le_bits" }, { start: 12897, name: "__to_be_bits" }, { start: 12972, name: "modulus_num_bits" }, { start: 13048, name: "modulus_be_bits" }, { start: 13124, name: "modulus_le_bits" }, { start: 13200, name: "modulus_be_bytes" }, { start: 13276, name: "modulus_le_bytes" }, { start: 13437, name: "__field_less_than" }, { start: 13513, name: "field_less_than" }, { start: 13589, name: "lt_fallback" }, { start: 14551, name: "tests::test_to_be_bits" }, { start: 14824, name: "tests::test_to_le_bits" }, { start: 15099, name: "tests::test_to_be_bytes" }, { start: 15405, name: "tests::test_to_le_bytes" }, { start: 15711, name: "tests::test_to_be_radix" }, { start: 16293, name: "tests::test_to_le_radix" }, { start: 16893, name: "tests::test_to_le_radix_1" }, { start: 17346, name: "tests::test_to_le_radix_brillig_1" }, { start: 17700, name: "tests::test_to_le_radix_3" }, { start: 18011, name: "tests::test_to_le_radix_brillig_3" }, { start: 18439, name: "tests::test_to_le_radix_512" }, { start: 18848, name: "tests::not_enough_limbs_brillig" }, { start: 19044, name: "tests::not_enough_limbs" }, { start: 19274, name: "tests::non_zero_field_to_le_bytes_zero_limbs" }, { start: 19469, name: "tests::non_zero_field_to_be_bytes_zero_limbs" }, { start: 19600, name: "tests::zero_field_to_bytes_zero_limbs_unconstrained" }, { start: 19915, name: "tests::zero_field_to_bytes_zero_limbs_constrained" }, { start: 20227, name: "tests::zero_field_to_bytes_zero_limbs_comptime" }, { start: 20558, name: "tests::test_field_less_than" }, { start: 20813, name: "tests::test_large_field_values_unconstrained" }, { start: 21266, name: "tests::test_large_field_values" }, { start: 21713, name: "tests::test_decomposition_edge_cases" }, { start: 22303, name: "tests::test_pow_32" }, { start: 22632, name: "tests::test_sgn0" }, { start: 23054, name: "tests::test_bit_decomposition_overflow" }, { start: 23336, name: "tests::test_byte_decomposition_overflow" }, { start: 23553, name: "tests::test_to_from_be_bytes_bn254_edge_cases" }, { start: 25504, name: "tests::test_to_from_le_bytes_bn254_edge_cases" }, { start: 27439, name: "tests::test_from_le_bytes_checked_accepts_modulus_minus_one" }, { start: 27918, name: "tests::test_from_le_bytes_checked_rejects_modulus" }, { start: 28303, name: "tests::test_from_le_bytes_checked_rejects_modulus_plus_one" }, { start: 28758, name: "tests::test_from_be_bytes_checked_accepts_modulus_minus_one" }, { start: 29247, name: "tests::test_from_be_bytes_checked_rejects_modulus" }, { start: 29632, name: "tests::test_from_be_bytes_checked_rejects_modulus_plus_one" }, { start: 30076, name: "tests::test_from_bytes_checked_small_n" }, { start: 30721, name: "tests::from_le_bits" }, { start: 31268, name: "tests::from_be_bits" }, { start: 31514, name: "tests::test_to_from_be_bits_bn254_edge_cases" }, { start: 33447, name: "tests::test_to_from_le_bits_bn254_edge_cases" }, { start: 35379, name: "tests::max_bit_size_too_large" }] }, "17": { 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', path: "std/hash/mod.nr", function_locations: [{ start: 572, name: "sha256_compression" }, { start: 707, name: "keccakf1600" }, { start: 852, name: "blake2s" }, { start: 950, name: "blake3" }, { start: 1437, name: "__blake3" }, { start: 1555, name: "pedersen_commitment" }, { start: 1784, name: "pedersen_commitment_with_separator" }, { start: 2188, name: "pedersen_hash" }, { start: 2345, name: "pedersen_hash_with_separator" }, { start: 3339, name: "derive_generators" }, { start: 3698, name: "__derive_generators" }, { start: 3776, name: "poseidon2_permutation" }, { start: 4132, name: "poseidon2_permutation_internal" }, { start: 4225, name: "poseidon2_config_state_size" }, { start: 4536, name: "derive_hash" }, { start: 5327, name: "Hasher::finish_ref" }, { start: 5761, name: "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher" }, { start: 5893, name: "<impl Default for BuildHasherDefault<H>>::default" }, { start: 6025, name: "<impl Hash for Field>::hash" }, { start: 6155, name: "<impl Hash for u8>::hash" }, { start: 6295, name: "<impl Hash for u16>::hash" }, { start: 6435, name: "<impl Hash for u32>::hash" }, { start: 6575, name: "<impl Hash for u64>::hash" }, { start: 6716, name: "<impl Hash for u128>::hash" }, { start: 6855, name: "<impl Hash for i8>::hash" }, { start: 7001, name: "<impl Hash for i16>::hash" }, { start: 7148, name: "<impl Hash for i32>::hash" }, { start: 7295, name: "<impl Hash for i64>::hash" }, { start: 7443, name: "<impl Hash for bool>::hash" }, { start: 7590, name: "<impl Hash for ()>::hash" }, { start: 7722, name: "<impl Hash for [T; N]>::hash" }, { start: 7911, name: "<impl Hash for [T]>::hash" }, { start: 8133, name: "<impl Hash for (A,)>::hash" }, { start: 8302, name: "<impl Hash for (A, B)>::hash" }, { start: 8518, name: "<impl Hash for (A, B, C)>::hash" }, { start: 8781, name: "<impl Hash for (A, B, C, D)>::hash" }, { start: 9091, name: "<impl Hash for (A, B, C, D, E)>::hash" }, { start: 9448, name: "<impl Hash for (A, B, C, D, E, F)>::hash" }, { start: 9852, name: "<impl Hash for (A, B, C, D, E, F, G)>::hash" }, { start: 10306, name: "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash" }, { start: 10807, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash" }, { start: 11355, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash" }, { start: 11950, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash" }, { start: 12593, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash" }, { start: 13187, name: "assert_pedersen" }] }, "52": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crisp_lib::ciphertext_addition::verify_slot_update;\nuse crisp_lib::ecdsa::{address_to_field, derive_address, digest_from_halves, validate_signature};\nuse crisp_lib::utils::{check_coefficient_values_with_balance, check_coefficient_zero};\nuse interfold_lib::configs::default::threshold::{\n L, N, QIS, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_K,\n};\nuse interfold_lib::math::{\n commitments::{compute_single_polynomial_commitment, DS_USER_DATA_ENCRYPTION_COMMITMENT},\n polynomial::Polynomial,\n};\n\n/// Main circuit function for CRISP vote verification, on-chain eligibility variant.\n///\n/// This circuit does the same work as the `crisp` circuit, but it takes the voting power of the\n/// slot from the contract instead of from a census Merkle tree. The contract reads the voting\n/// power from the token at the snapshot of the round, and supplies it as a public input.\n///\n/// The `crisp` circuit is for a census that the contract cannot compute, such as an address\n/// allowlist. This circuit is for a census that comes from an on-chain token. Removing the tree\n/// removes the trusted census producer, and it removes the Merkle path from each proof.\n///\n/// The circuit covers three operations:\n/// 1. **Voting**: An eligible voter casts a ballot into an empty slot\n/// 2. **Updating**: The same voter replaces the ballot in their slot\n/// 3. **Masking**: Anyone adds a zero ballot to any eligible slot\n///\n/// Votes are stored in an on-chain Merkle tree, where each vote ciphertext is stored at a specific\n/// index. A mapping stores the slot address (Ethereum address) to the index in the Merkle tree.\n/// - For actual votes: the slot address must match the address derived from the signature\n/// - For mask votes: the slot address can be any address (no address match required)\n/// In both cases, the contract must confirm that the slot has voting power before it accepts the\n/// input. The circuit cannot make that check, because it has no view of the token.\n///\n/// Mask votes weaken receipt sharing: anyone can submit a zero vote to any slot, which creates a\n/// different ciphertext that decrypts to the same value. The on-chain activity of a slot then does\n/// not show which ciphertext holds its owner's vote. This holds only while the committee does not\n/// decrypt individual ballots and the public tally does not itself show the choice.\n///\n/// # One relation for all three operations\n///\n/// The circuit proves the same statement whichever operation is being performed:\n///\n/// ```text\n/// new slot ciphertext = addend + ballot ciphertext\n/// ```\n///\n/// where the ballot ciphertext is a fresh BFV encryption of `k1`, and the addend is the ciphertext\n/// already in the slot for a mask, or the zero ciphertext for a vote, an update, and any input to\n/// an empty slot. `is_mask_vote` chooses between them and is private, so the returned commitment,\n/// the public inputs, and the published ciphertext have the same shape in every case. An observer\n/// cannot tell a vote from an update from a mask; distinguishing them would mean distinguishing a\n/// fresh BFV ciphertext from a sum, which is what the encryption scheme hides.\n///\n/// The circuit returns:\n/// - `sum_ct_commitment` - the commitment to the ciphertext that becomes the slot, and the value\n/// the E3 program stores and the ballot digest is built over\n/// - `ct_commitment` - the commitment to the ballot ciphertext, which ties this proof to the\n/// `user_data_encryption` proof in the fold circuit\n/// - `k1_commitment` - the commitment to the ballot plaintext, for the same reason\n///\nfn main(\n // Ciphertext Addition Section\n prev_ct0is: [Polynomial<N>; L],\n prev_ct1is: [Polynomial<N>; L],\n prev_ct_commitment: pub Field,\n sum_ct0is: [Polynomial<N>; L],\n sum_ct1is: [Polynomial<N>; L],\n sum_r0is: [Polynomial<N>; L],\n sum_r1is: [Polynomial<N>; L],\n // User Data Encryption Section.\n ct0is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n k1: Polynomial<N>,\n // ECDSA Section.\n public_key_x: [u8; 32],\n public_key_y: [u8; 32],\n signature: [u8; 64],\n digest_hi: pub Field,\n digest_lo: pub Field,\n // Eligibility Section. The contract supplies both values.\n slot_address: pub Field,\n voting_power: pub Field,\n // Other inputs.\n is_first_vote: pub bool,\n is_mask_vote: bool,\n num_options: pub u32,\n) -> pub (Field, Field, Field) {\n // ============================================================================\n // STEP 1: The Plaintext Commitment\n // ============================================================================\n // Links this circuit to the user_data_encryption proof in the fold circuit, which covers the\n // same plaintext.\n let k1_commitment = compute_single_polynomial_commitment::<N, USER_DATA_ENCRYPTION_BIT_K>(\n k1,\n DS_USER_DATA_ENCRYPTION_COMMITMENT,\n );\n\n // ============================================================================\n // STEP 2: Eligibility\n // ============================================================================\n // There is no Merkle proof in this circuit. `slot_address` and `voting_power` are public\n // inputs that the contract sets from the token at the snapshot of the round, so the prover\n // cannot change either value.\n //\n // The contract must reject an input when the slot has no voting power. That check applies to\n // actual votes and to mask votes, and it replaces the tree membership proof of the `crisp`\n // circuit.\n\n // ============================================================================\n // STEP 3: The Slot Update\n // ============================================================================\n // Prove that sum_ct = addend + ct, where ct = (ct0is, ct1is) is the ballot ciphertext,\n // sum_ct = (sum_ct0is, sum_ct1is) is what the E3 program will store for this slot, and the\n // addend is the slot's current ciphertext for a mask and zero otherwise. A mask must open\n // `prev_ct_commitment`, the commitment the E3 program recorded for the entry this input names as\n // its parent.\n //\n // Asserted on every path. That is what constrains the published ciphertext: it is the ballot\n // the `user_data_encryption` proof covers, added to the ciphertext the slot already held, and\n // nothing else. Without it a submitter could publish arbitrary bytes into someone's slot.\n let (sum_ct_commitment, ct_commitment) = verify_slot_update::<N, L, USER_DATA_ENCRYPTION_BIT_CT>(\n QIS,\n prev_ct0is,\n prev_ct1is,\n prev_ct_commitment,\n sum_ct0is,\n sum_ct1is,\n sum_r0is,\n sum_r1is,\n ct0is,\n ct1is,\n is_first_vote,\n is_mask_vote,\n );\n\n // ============================================================================\n // STEP 4: Ballot Rules\n // ============================================================================\n // CASE 1: ACTUAL VOTE (is_mask_vote == false)\n // - This is an eligible voter casting or replacing a ballot\n // - Verify the ballot is well formed and worth no more than the voting power (valid_vote)\n // - Validate the signature over the public digest (valid_signature) to authenticate the\n // voter for this ballot\n // - Verify the signing address matches the slot address (valid_address)\n //\n // CASE 2: MASK VOTE (is_mask_vote == true)\n // - This is anyone adding a zero ballot to mask slot activity\n // - Verify the plaintext is zero everywhere (valid_zero_vote), so a mask cannot change what\n // the slot decrypts to, and cannot carry a payload a coercer could read back out of the\n // tally\n // - No signature is required, which is what lets a third party mask a slot at all\n let valid_vote = check_coefficient_values_with_balance(k1, voting_power, num_options);\n\n // The digest is a public input, so the prover cannot select the message that the signature\n // covers. The contract computes the digest from the round, the slot, and this ballot, which\n // binds the signature to all three.\n let hashed_message = digest_from_halves(digest_hi, digest_lo);\n let valid_signature = validate_signature(hashed_message, public_key_x, public_key_y, signature);\n let valid_address =\n slot_address == address_to_field(derive_address(public_key_x, public_key_y));\n\n let valid_zero_vote = check_coefficient_zero(k1, num_options);\n\n if is_mask_vote {\n assert(valid_zero_vote);\n } else {\n assert(valid_vote);\n assert(valid_signature);\n assert(valid_address);\n }\n\n (sum_ct_commitment, ct_commitment, k1_commitment)\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/bin/crisp_onchain/src/main.nr", function_locations: [{ start: 4603, name: "main" }] }, "53": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! # The slot update every CRISP input proves\n//!\n//! Voting, updating, and masking all prove one relation between three BFV ciphertexts:\n//!\n//! ```text\n//! published slot ciphertext = addend + ballot ciphertext (mod q_i, coefficient by coefficient)\n//! ```\n//!\n//! The addend is the ciphertext already in the slot for a mask, and the zero ciphertext for a\n//! vote, an update, and any input to an empty slot. [`verify_slot_update`] is the one place both\n//! ballot circuits (`crisp` and `crisp_onchain`) prove it.\n//!\n//! ## Why the relation is checked at every coefficient\n//!\n//! The three ciphertexts reach the rest of the protocol only through their SAFE commitments: the\n//! ballot\'s through the `user_data_encryption` fold, the parent\'s through the commitment\n//! `CRISPProgram` stored for it, and the result\'s through the bytes the Secure Process opens. Those\n//! commitments pack coefficients into shared carriers with `pack`, which is not injective: a\n//! coefficient can overflow its slot and cancel against the next one, so a prover can open a\n//! commitment to coefficients other than the committed ones.\n//!\n//! A check at one Fiat-Shamir point cannot survive that. The point depends only on the\n//! commitments, so a prover fixes it first and then picks an opening, or quotients, that satisfy\n//! the one equation. That is how a mask could publish a ciphertext that drops the vote it names.\n//!\n//! The relation here is linear and aligned coefficient by coefficient across the three\n//! ciphertexts, which all pack with the same `BIT_CT` layout. An opening that keeps the carriers\n//! of a commitment differs from the committed coefficients by a vector the packing sends to zero.\n//! Summing the per-coefficient equations with the carrier weights therefore gives the same\n//! equation for the committed coefficients:\n//!\n//! ```text\n//! sum_k (published_k - ballot_k - addend_k) * radix^(g-1-k) = q_i * sum_k r_k * radix^(g-1-k)\n//! ```\n//!\n//! The committed coefficients are bounded (the ballot by `user_data_encryption`, the parent and the\n//! result by their canonical bytes) and each `r_k` is in `[-1, 1]`, so both sides are far below the\n//! field modulus and every base-`radix` digit fits its slot. The equation then holds over the\n//! integers digit by digit, which is `published_k = ballot_k + addend_k + q_i * r_k` for the\n//! committed coefficients. No choice of opening changes what the relation proves, so the packing\n//! does not need the digit asserts of `pack_checked`, which would put the ballot circuit above the\n//! browser prover\'s `2^21` gate ceiling.\n\nuse interfold_lib::math::commitments::compute_ciphertext_commitment;\nuse interfold_lib::math::polynomial::Polynomial;\n\n/// The ciphertext an input adds to, which is either the one already in the slot or nothing.\n///\n/// A mask keeps what the slot holds, so its addend is that ciphertext. A real vote replaces the\n/// slot, and a first input has nothing to replace, so both add to the zero ciphertext instead.\n///\n/// Selecting here rather than branching keeps the addition constraints live on every path. The\n/// alternative \u2014 proving the addition only for masks \u2014 leaves the published ciphertext of a real\n/// vote unconstrained, and makes the two paths different shapes of proof.\n///\n/// # Arguments\n/// * `polynomials` - The ciphertext limbs already in the slot\n/// * `keep` - Whether this input adds to them\n///\n/// # Returns\n/// The limbs when `keep` is true, all zeros otherwise.\npub fn select_addend<let N: u32, let L: u32>(\n polynomials: [Polynomial<N>; L],\n keep: bool,\n) -> [Polynomial<N>; L] {\n let factor: Field = if keep { 1 } else { 0 };\n\n let mut selected = polynomials;\n for i in 0..L {\n selected[i] = polynomials[i].mul_scalar(factor);\n }\n\n selected\n}\n\n/// Constrains the slot update of one CRISP input and returns the commitments it links to.\n///\n/// Proves `sum = addend + ballot` coefficient by coefficient, where the addend is the slot\'s\n/// current ciphertext for a mask and zero otherwise. The selector is derived, not witnessed:\n/// `keep_previous = is_mask_vote & !is_first_vote`. A voter therefore cannot add a new ballot on\n/// top of an old one and count twice, and a masker cannot discard what the slot holds.\n///\n/// A mask must open `prev_ct_commitment`, the commitment `CRISPProgram` stored for the entry the\n/// input names as its parent. A vote adds to nothing and opens nothing, so it can write to its own\n/// slot whatever the parent turns out to be: `CRISPProgram` cannot tell whether a parent\'s bytes\n/// reproduce its commitment, and only the Secure Process can, once the input window closes.\n///\n/// # Arguments\n/// * `qis` - The CRT moduli\n/// * `prev_ct0is`, `prev_ct1is` - The ciphertext already in the slot\n/// * `prev_ct_commitment` - The commitment `CRISPProgram` stored for the parent entry, or zero\n/// * `sum_ct0is`, `sum_ct1is` - The ciphertext this input publishes as the slot\n/// * `sum_r0is`, `sum_r1is` - The per-coefficient quotients of the addition, each in `[-1, 1]`\n/// * `ct0is`, `ct1is` - The ballot ciphertext, which `user_data_encryption` proves\n/// * `is_first_vote` - Whether the input names no parent\n/// * `is_mask_vote` - Whether the input keeps what the slot holds\n///\n/// # Returns\n/// `(sum_ct_commitment, ct_commitment)`: the commitment the slot takes, and the ballot commitment\n/// the fold links to `user_data_encryption`.\npub fn verify_slot_update<let N: u32, let L: u32, let BIT_CT: u32>(\n qis: [Field; L],\n prev_ct0is: [Polynomial<N>; L],\n prev_ct1is: [Polynomial<N>; L],\n prev_ct_commitment: Field,\n sum_ct0is: [Polynomial<N>; L],\n sum_ct1is: [Polynomial<N>; L],\n sum_r0is: [Polynomial<N>; L],\n sum_r1is: [Polynomial<N>; L],\n ct0is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n is_first_vote: bool,\n is_mask_vote: bool,\n) -> (Field, Field) {\n let ct_commitment = compute_ciphertext_commitment::<N, L, BIT_CT>(ct0is, ct1is);\n let sum_ct_commitment = compute_ciphertext_commitment::<N, L, BIT_CT>(sum_ct0is, sum_ct1is);\n\n let keep_previous = is_mask_vote & !is_first_vote;\n // Computed on every path, so the three operations prove the same shape of statement.\n let recomputed_prev_ct_commitment =\n compute_ciphertext_commitment::<N, L, BIT_CT>(prev_ct0is, prev_ct1is);\n if keep_previous {\n assert(\n prev_ct_commitment == recomputed_prev_ct_commitment,\n "the addend does not open the parent commitment",\n );\n }\n\n let addend_ct0is = select_addend(prev_ct0is, keep_previous);\n let addend_ct1is = select_addend(prev_ct1is, keep_previous);\n\n for i in 0..L {\n // The sum of two coefficients in `(-q_i, q_i)` differs from its centered residue by at\n // most one `q_i`, so `[-1, 1]` covers every honest quotient. The bound is also what lets\n // the per-coefficient equations hold over the integers.\n sum_r0is[i].range_check_2bounds::<1>(1, 1);\n sum_r1is[i].range_check_2bounds::<1>(1, 1);\n\n for k in 0..N {\n assert(\n sum_ct0is[i].coefficients[k]\n == ct0is[i].coefficients[k]\n + addend_ct0is[i].coefficients[k]\n + qis[i] * sum_r0is[i].coefficients[k],\n "the published ciphertext is not the ballot added to the addend",\n );\n assert(\n sum_ct1is[i].coefficients[k]\n == ct1is[i].coefficients[k]\n + addend_ct1is[i].coefficients[k]\n + qis[i] * sum_r1is[i].coefficients[k],\n "the published ciphertext is not the ballot added to the addend",\n );\n }\n }\n\n (sum_ct_commitment, ct_commitment)\n}\n\n// ---------------------------------------------------------------------------\n// Tests\n// ---------------------------------------------------------------------------\n//\n// Reduced dimensions: four coefficients, one small modulus, and a 16-bit packing layout (a radix\n// of 2^20, twelve digits per carrier). The relation and the packing are the production functions.\n\nglobal TEST_N: u32 = 4;\nglobal TEST_L: u32 = 1;\nglobal TEST_BIT_CT: u32 = 16;\nglobal TEST_Q: Field = 40961;\nglobal TEST_QIS: [Field; TEST_L] = [TEST_Q];\n\nfn ciphertext(\n c0: [Field; TEST_N],\n c1: [Field; TEST_N],\n) -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ([Polynomial::new(c0)], [Polynomial::new(c1)])\n}\n\nfn commit(ct: ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L])) -> Field {\n compute_ciphertext_commitment::<TEST_N, TEST_L, TEST_BIT_CT>(ct.0, ct.1)\n}\n\nfn no_quotients() -> [Polynomial<TEST_N>; TEST_L] {\n [Polynomial::new([0; TEST_N])]\n}\n\n/// The ciphertext already in the slot.\nfn slot_head() -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ciphertext([1200, -3400, 20000, 17], [-9, 8000, -20000, 5])\n}\n\n/// A fresh ballot ciphertext.\nfn ballot() -> ([Polynomial<TEST_N>; TEST_L], [Polynomial<TEST_N>; TEST_L]) {\n ciphertext([300, 45, 1000, -2], [7, -600, -1000, 11])\n}\n\n#[test]\nfn a_vote_publishes_its_ballot_alone() {\n let ballot = ballot();\n let empty = ciphertext([0; TEST_N], [0; TEST_N]);\n\n let (sum_commitment, ct_commitment) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n empty.0,\n empty.1,\n 0,\n ballot.0,\n ballot.1,\n no_quotients(),\n no_quotients(),\n ballot.0,\n ballot.1,\n true,\n false,\n );\n\n assert(sum_commitment == commit(ballot));\n assert(ct_commitment == commit(ballot));\n}\n\n/// An update names the slot\'s head as its parent but replaces it, so it adds to nothing.\n#[test]\nfn an_update_replaces_the_ballot_in_the_slot() {\n let head = slot_head();\n let ballot = ballot();\n\n let (sum_commitment, _) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n ballot.0,\n ballot.1,\n no_quotients(),\n no_quotients(),\n ballot.0,\n ballot.1,\n false,\n false,\n );\n\n assert(sum_commitment == commit(ballot));\n}\n\n/// A mask keeps the ballot in the slot. Two coefficients wrap past `q / 2` and need the quotient.\n#[test]\nfn a_mask_keeps_the_ballot_in_the_slot() {\n let head = slot_head();\n let mask = ballot();\n // 20000 + 1000 = 21000 wraps to 21000 - q, and -20000 - 1000 = -21000 wraps to q - 21000.\n let sum = ciphertext(\n [1500, -3355, 21000 - TEST_Q, 15],\n [-2, 7400, TEST_Q - 21000, 16],\n );\n let r0 = [Polynomial::new([0, 0, -1, 0])];\n let r1 = [Polynomial::new([0, 0, 1, 0])];\n\n let (sum_commitment, _) = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n sum.0,\n sum.1,\n r0,\n r1,\n mask.0,\n mask.1,\n false,\n true,\n );\n\n assert(sum_commitment == commit(sum));\n}\n\n#[test(should_fail_with = "the published ciphertext is not the ballot added to the addend")]\nfn a_mask_cannot_publish_its_ballot_without_the_slot() {\n let head = slot_head();\n let mask = ballot();\n\n let _ = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n head.0,\n head.1,\n commit(head),\n mask.0,\n mask.1,\n no_quotients(),\n no_quotients(),\n mask.0,\n mask.1,\n false,\n true,\n );\n}\n\n/// The demonstrated forgery: a mask that publishes only its own ballot, and so erases the vote in\n/// the slot, with a second opening of the parent commitment.\n///\n/// The parent opening differs from the head only by `delta * v`, where `v = (1, -radix, 0, 0)` is a\n/// carry that the packing maps to zero, so it opens the same commitment. A check at one\n/// Fiat-Shamir point derived from the three commitments accepted it once `delta` solved that one\n/// equation. The attacker computes that point the way such a check derived it.\n#[test(should_fail_with = "the published ciphertext is not the ballot added to the addend")]\nfn a_second_opening_of_the_parent_cannot_erase_the_slot() {\n let head = slot_head();\n let mask = ballot();\n let parent_commitment = commit(head);\n let published_commitment = commit(mask);\n\n let domain_separator: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x43, 0x54, 0x5f, 0x41, 0x44, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00,\n ];\n let gammas = interfold_lib::math::commitments::compute_challenge::<TEST_L>(\n [published_commitment, parent_commitment, published_commitment].as_vector(),\n domain_separator,\n );\n let gamma = gammas[0];\n\n // The single-point check was `(published0 - ballot0 - addend0)(gamma) +\n // gammas[1] * (published1 - ballot1 - addend1)(gamma) == 0` with zero quotients. Publishing the\n // mask ballot alone leaves `addend0(gamma) = -gammas[1] * head1(gamma)`.\n let radix: Field = 1048576;\n let carry = Polynomial::new([1, -radix, 0, 0]);\n let delta = (0 - gammas[1] * head.1[0].eval(gamma) - head.0[0].eval(gamma)) / carry.eval(gamma);\n let forged0 = [head.0[0].add(carry.mul_scalar(delta))];\n\n assert(\n compute_ciphertext_commitment::<TEST_N, TEST_L, TEST_BIT_CT>(forged0, head.1)\n == parent_commitment,\n "the forged opening must open the parent commitment",\n );\n\n let _ = verify_slot_update::<TEST_N, TEST_L, TEST_BIT_CT>(\n TEST_QIS,\n forged0,\n head.1,\n parent_commitment,\n mask.0,\n mask.1,\n no_quotients(),\n no_quotients(),\n mask.0,\n mask.1,\n false,\n true,\n );\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/ciphertext_addition.nr", function_locations: [{ start: 3798, name: "select_addend" }, { start: 6074, name: "verify_slot_update" }, { start: 8622, name: "ciphertext" }, { start: 8763, name: "commit" }, { start: 8895, name: "no_quotients" }, { start: 9054, name: "slot_head" }, { start: 9230, name: "ballot" }, { start: 9340, name: "a_vote_publishes_its_ballot_alone" }, { start: 9976, name: "an_update_replaces_the_ballot_in_the_slot" }, { start: 10542, name: "a_mask_keeps_the_ballot_in_the_slot" }, { start: 11372, name: "a_mask_cannot_publish_its_ballot_without_the_slot" }, { start: 12398, name: "a_second_opening_of_the_parent_cannot_erase_the_slot" }] }, "55": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\n\n/// Validates an ECDSA signature over a hashed message.\n///\n/// This function validates that a signature was created by the holder of the private key\n/// corresponding to the provided public key, and that it signs the given hashed message.\n///\n/// # Arguments\n/// * `hashed_message` - The Keccak256 hash of the message being signed (32 bytes)\n/// * `pub_key_x` - The x-coordinate of the public key (32 bytes, big-endian)\n/// * `pub_key_y` - The y-coordinate of the public key (32 bytes, big-endian)\n/// * `signature` - The ECDSA signature (64 bytes: r || s, both 32 bytes big-endian)\n///\n/// # Returns\n/// Returns `true` if the signature is valid, `false` otherwise.\n///\n/// # Note\n/// The signature is verified using secp256k1 curve (same as Ethereum). The message\n/// should already be hashed before calling this function.\npub fn validate_signature(\n hashed_message: [u8; 32],\n pub_key_x: [u8; 32],\n pub_key_y: [u8; 32],\n signature: [u8; 64],\n) -> bool {\n std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message)\n}\n\n/// Derives an Ethereum address from a secp256k1 public key.\n///\n/// This function implements the standard Ethereum address derivation algorithm:\n/// 1. Concatenate the public key coordinates (64 bytes total)\n/// 2. Compute Keccak256 hash of the concatenated bytes\n/// 3. Extract the last 20 bytes as the address\n///\n/// # Arguments\n/// * `pub_key_x` - The x-coordinate of the public key (32 bytes, big-endian)\n/// * `pub_key_y` - The y-coordinate of the public key (32 bytes, big-endian)\n///\n/// # Returns\n/// A 20-byte array representing the Ethereum address.\npub fn derive_address(pub_key_x: [u8; 32], pub_key_y: [u8; 32]) -> [u8; 20] {\n let mut pub_key_bytes = [0; 64];\n for i in 0..32 {\n pub_key_bytes[i] = pub_key_x[i];\n pub_key_bytes[i + 32] = pub_key_y[i];\n }\n\n // Hash the concatenated public key\n let hash = keccak256(pub_key_bytes, 64);\n\n // Extract last 20 bytes as the Ethereum address\n let mut derived_address = [0; 20];\n for i in 0..20 {\n derived_address[i] = hash[i + 12];\n }\n\n derived_address\n}\n\n/// Converts a 20-byte Ethereum address to a field element.\n///\n/// This function interprets the address bytes as a big-endian integer and converts it\n/// to a field element.\n///\n/// # Arguments\n/// * `addr` - A 20-byte Ethereum address\n///\n/// # Returns\n/// A field element representing the address as an integer.\npub fn address_to_field(addr: [u8; 20]) -> Field {\n let mut acc: Field = 0;\n\n for i in 0..20 {\n acc = acc * 256 + (addr[i] as Field);\n }\n\n acc\n}\n\n/// Rebuilds the 32-byte signed digest from its two field halves.\n///\n/// A Keccak-256 digest is 256 bits, but a field element holds fewer than 254 bits. The digest\n/// therefore enters a circuit as two public inputs. `digest_hi` holds the first 16 bytes and\n/// `digest_lo` holds the last 16 bytes. Both halves are big-endian.\n///\n/// `to_be_bytes` constrains each half to 16 bytes, so each half has one representation only.\n///\n/// # Arguments\n/// * `digest_hi` - The first 16 bytes of the digest, as a big-endian integer\n/// * `digest_lo` - The last 16 bytes of the digest, as a big-endian integer\n///\n/// # Returns\n/// The 32-byte digest.\npub fn digest_from_halves(digest_hi: Field, digest_lo: Field) -> [u8; 32] {\n let hi: [u8; 16] = digest_hi.to_be_bytes();\n let lo: [u8; 16] = digest_lo.to_be_bytes();\n\n let mut digest = [0; 32];\n for i in 0..16 {\n digest[i] = hi[i];\n digest[i + 16] = lo[i];\n }\n\n digest\n}\n\n#[test]\nfn test_derive_address() {\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let address = derive_address(pub_key_x, pub_key_y);\n assert(\n address\n == [\n 243, 159, 214, 229, 26, 173, 136, 246, 244, 206, 106, 184, 130, 114, 121, 207, 255,\n 185, 34, 102,\n ],\n );\n}\n\n#[test]\nfn test_validate_signature() {\n let hashed_message = [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104, 152,\n 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ];\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_validate_signature_sdk_input() {\n let hashed_message = [\n 200, 232, 98, 162, 80, 131, 242, 57, 252, 76, 226, 45, 127, 206, 207, 39, 206, 44, 211, 171,\n 113, 67, 121, 68, 78, 253, 202, 79, 29, 128, 130, 76,\n ];\n\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 22, 65, 67, 29, 14, 211, 253, 134, 129, 79, 2, 109, 166, 46, 17, 67, 75, 83, 198, 168, 81,\n 98, 254, 167, 249, 146, 24, 191, 60, 48, 125, 236, 127, 54, 28, 35, 95, 7, 182, 88, 120, 10,\n 253, 145, 165, 201, 214, 141, 106, 75, 20, 213, 235, 5, 17, 246, 104, 141, 62, 145, 20, 14,\n 236, 18,\n ];\n\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_digest_from_halves() {\n let digest = digest_from_halves(\n 0x437e9da4a2a538f29bd671c453c6e424,\n 0xae689857a76c4022eaa17a372c3e9737,\n );\n\n assert(\n digest\n == [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104,\n 152, 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ],\n );\n}\n\n#[test]\nfn test_digest_from_halves_matches_signature() {\n // The same digest as `test_validate_signature`, supplied as two halves.\n let digest = digest_from_halves(\n 0x437e9da4a2a538f29bd671c453c6e424,\n 0xae689857a76c4022eaa17a372c3e9737,\n );\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n\n assert(validate_signature(digest, pub_key_x, pub_key_y, signature));\n}\n\n/// A signature is valid only for the digest it covers.\n///\n/// This is the property the ballot binding depends on. The digest is a public input that the\n/// contract computes from the round, the slot, and the ballot, so a signature taken from anywhere\n/// else cannot be replayed onto a different ballot. Before the digest became a public input, the\n/// message was a free witness and any signature by the slot key was accepted.\n#[test(should_fail)]\nfn test_fail_signature_over_different_digest() {\n // The key and signature of `test_validate_signature`, checked against the digest of\n // `test_validate_signature_sdk_input`.\n let other_digest = digest_from_halves(\n 0xc8e862a25083f239fc4ce22d7fcecf27,\n 0xce2cd3ab714379444efdca4f1d80824c,\n );\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 152,\n ];\n\n assert(validate_signature(other_digest, pub_key_x, pub_key_y, signature));\n}\n\n#[test(should_fail)]\nfn test_fail_digest_half_too_large() {\n // A half that needs more than 16 bytes has no unique encoding, so `to_be_bytes` must reject it.\n let _ = digest_from_halves(0x0100000000000000000000000000000000, 0);\n}\n\n#[test(should_fail)]\nfn test_fail_validate_signature() {\n // This test verifies that invalid signatures cause validation to fail.\n // The test itself will fail (assertion failure) when validate_signature is called\n // with an invalid signature, which demonstrates that invalid signatures are properly rejected.\n let hashed_message = [\n 67, 126, 157, 164, 162, 165, 56, 242, 155, 214, 113, 196, 83, 198, 228, 36, 174, 104, 152,\n 87, 167, 108, 64, 34, 234, 161, 122, 55, 44, 62, 151, 55,\n ];\n let pub_key_x = [\n 131, 24, 83, 91, 84, 16, 93, 74, 122, 174, 96, 192, 143, 196, 95, 150, 135, 24, 27, 79, 223,\n 198, 37, 189, 26, 117, 63, 167, 57, 127, 237, 117,\n ];\n let pub_key_y = [\n 53, 71, 241, 28, 168, 105, 102, 70, 242, 243, 172, 176, 142, 49, 1, 106, 250, 194, 62, 99,\n 12, 93, 17, 245, 159, 97, 254, 245, 123, 13, 42, 165,\n ];\n let signature = [\n 78, 219, 63, 96, 214, 92, 16, 36, 108, 207, 133, 108, 3, 248, 122, 23, 192, 236, 210, 253,\n 206, 125, 83, 124, 163, 54, 106, 125, 188, 223, 192, 39, 44, 76, 228, 107, 188, 221, 183,\n 124, 118, 143, 228, 126, 216, 173, 160, 231, 62, 52, 188, 154, 110, 230, 183, 71, 36, 161,\n 171, 163, 213, 62, 223, 151,\n ];\n\n // This call should fail (assertion failure) because the signature is invalid\n assert(validate_signature(hashed_message, pub_key_x, pub_key_y, signature));\n}\n\n#[test]\nfn test_address_to_field() {\n let address: [u8; 20] = [\n 243, 159, 214, 229, 26, 173, 136, 246, 244, 206, 106, 184, 130, 114, 121, 207, 255, 185, 34,\n 102,\n ];\n let field = address_to_field(address);\n\n assert(field == 0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/ecdsa.nr", function_locations: [{ start: 1183, name: "validate_signature" }, { start: 1918, name: "derive_address" }, { start: 2708, name: "address_to_field" }, { start: 3541, name: "digest_from_halves" }, { start: 3804, name: "test_derive_address" }, { start: 4478, name: "test_validate_signature" }, { start: 5551, name: "test_validate_signature_sdk_input" }, { start: 6598, name: "test_digest_from_halves" }, { start: 7038, name: "test_digest_from_halves_matches_signature" }, { start: 8565, name: "test_fail_signature_over_different_digest" }, { start: 9720, name: "test_fail_digest_half_too_large" }, { start: 9954, name: "test_fail_validate_signature" }, { start: 11361, name: "test_address_to_field" }] }, "58": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse interfold_lib::configs::default::MAX_MSG_NON_ZERO_COEFFS;\nuse interfold_lib::configs::default::threshold::{\n PLAINTEXT_MODULUS, Q_INVERSE_MOD_T, Q_MOD_T, USER_DATA_ENCRYPTION_BIT_K,\n};\nuse interfold_lib::math::helpers::assert_in_range;\nuse interfold_lib::math::modulo::unconstrained_U128::__compute_mod_reduction;\nuse interfold_lib::math::polynomial::Polynomial;\n\nuse crate::constants::MAX_OPTIONS;\n\n/// Checks the option count of a round. Every option must sit inside the first\n/// `MAX_MSG_NON_ZERO_COEFFS` message coefficients, which the committee publishes as the tally, and\n/// the degree `D` must hold them. The last two assertions are decided when the circuit is built.\nfn check_option_count<let D: u32>(num_options: u32) {\n assert(num_options > 1);\n assert(num_options <= MAX_OPTIONS);\n assert(MAX_OPTIONS <= MAX_MSG_NON_ZERO_COEFFS);\n assert(MAX_MSG_NON_ZERO_COEFFS <= D);\n}\n\n/// Checks that `weight` is the value the committee decrypts the option coefficient to.\n///\n/// The witness generator scales each message coefficient `m` to `k1 = (Q_MOD_T * m) mod t`, so\n/// `k1 + t * quotient == Q_MOD_T * weight`. With all three values in `[0, t)`, neither side reaches\n/// `t * t`, so the equation holds over the integers, and one weight solves it because `Q_MOD_T` is\n/// invertible modulo `t`.\n///\n/// The bound on the coefficient also makes this `k1` the plaintext that `user_data_encryption_ct0`\n/// encrypts. That circuit bounds its `k1` to `[0, t)`, the fold only checks that the two\n/// `k1_commitment` values are equal, and a packed commitment has one opening only while every\n/// coefficient fits its slot.\nfn check_weight(coefficient: Field, weight: Field, quotient: Field) {\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(coefficient, PLAINTEXT_MODULUS);\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(weight, PLAINTEXT_MODULUS);\n assert_in_range::<USER_DATA_ENCRYPTION_BIT_K>(quotient, PLAINTEXT_MODULUS);\n assert(coefficient + PLAINTEXT_MODULUS * quotient == Q_MOD_T * weight);\n}\n\n/// Computes the weight and the quotient that [`check_weight`] checks.\nunconstrained fn decode_weight_hint(coefficient: Field) -> (Field, Field) {\n let (_, weight) = __compute_mod_reduction(coefficient * Q_INVERSE_MOD_T, PLAINTEXT_MODULUS);\n let (quotient, _) = __compute_mod_reduction(Q_MOD_T * weight, PLAINTEXT_MODULUS);\n (weight, quotient)\n}\n\n/// Validates a ballot against the voter's balance.\n///\n/// A ballot holds one coefficient per option, so the decrypted tally holds per-option totals. `k1`\n/// is the whole BFV plaintext of degree `D`, reversed, so option `o` is `k1[D - 1 - o]`:\n///\n/// ```text\n/// [ ------------------ zero ------------------ | option n-1 | ... | option 1 | option 0 ]\n/// 0 D\n/// ```\n///\n/// Every other coefficient must be zero, so no payload outside the ballot reaches the tally. The\n/// weights must sum to at most `balance`, and with two options at most one weight is non-zero.\n///\n/// # Arguments\n/// * `k1` - The plaintext polynomial encoding the vote\n/// * `balance` - The voter's balance/voting power\n/// * `num_options` - Number of voting options\npub fn check_coefficient_values_with_balance<let D: u32>(\n k1: Polynomial<D>,\n balance: Field,\n num_options: u32,\n) -> bool {\n check_option_count::<D>(num_options);\n\n let mut valid = true;\n for i in 0..(D - MAX_OPTIONS) {\n valid = valid & (k1.coefficients[i] == 0);\n }\n\n let mut total: Field = 0;\n let mut non_zero_count: u32 = 0;\n for option in 0..MAX_OPTIONS {\n let coefficient = k1.coefficients[D - 1 - option];\n // Safety: `check_weight` constrains both values.\n let (weight, quotient) = unsafe { decode_weight_hint(coefficient) };\n check_weight(coefficient, weight, quotient);\n\n if option < num_options {\n total += weight;\n if weight != 0 {\n non_zero_count += 1;\n }\n } else {\n valid = valid & (coefficient == 0);\n }\n }\n\n if num_options == 2 {\n valid = valid & (non_zero_count <= 1);\n }\n\n // At most `MAX_OPTIONS` weights below `t` fit in a u64, so this cast is exact. Truncating the\n // balance can only lower the bound.\n valid & ((total as u64) <= (balance as u64))\n}\n\n/// Checks that every coefficient of `k1` is zero, not only the option coefficients. A mask needs no\n/// signature, so anyone may write one to any eligible slot, and a payload anywhere in it would\n/// reach that slot. `num_options` is still checked, so a mask cannot pass for a round that the\n/// vote rules refuse.\npub fn check_coefficient_zero<let D: u32>(k1: Polynomial<D>, num_options: u32) -> bool {\n check_option_count::<D>(num_options);\n\n let mut valid = true;\n for i in 0..D {\n valid = valid & (k1.coefficients[i] == 0);\n }\n valid\n}\n\n// Tests build `k1` the way the witness generator does and take `t` and `Q_MOD_T` from the compiled\n// preset, so they hold for any plaintext modulus of at least 100.\n\n/// The degree of the `insecure-64` preset, well above `MAX_OPTIONS`, so the layout is read from\n/// the real degree.\nglobal TEST_DEGREE: u32 = 64;\n\n/// The `k1` coefficient the witness generator produces for one message coefficient.\nfn scale(m: u64) -> Field {\n (((Q_MOD_T as u64) * m) % (PLAINTEXT_MODULUS as u64)) as Field\n}\n\n/// Builds `k1` the way `encodeVote` and the witness generator do: the weight of option `o`, scaled,\n/// at `k1[D - 1 - o]`, and zero everywhere else.\nfn encode_ballot<let N: u32>(weights: [u64; N]) -> Polynomial<TEST_DEGREE> {\n let mut coefficients = [0; TEST_DEGREE];\n for option in 0..N {\n coefficients[TEST_DEGREE - 1 - option] = scale(weights[option]);\n }\n Polynomial { coefficients }\n}\n\n/// Each row: the weights of options 0 to 2, the option count, the balance, and whether the vote\n/// rules accept the ballot.\n#[test]\nfn test_vote_rules() {\n let top = (PLAINTEXT_MODULUS as u64) - 1;\n let rows: [([u64; 3], u32, u64, bool); 7] = [\n ([0, 3, 0], 2, 10, true),\n ([1, 1, 0], 2, 10, false),\n // The largest weight decodes exactly, so the balance bound is tight.\n ([top, 0, 0], 2, top, true),\n ([top, 0, 0], 2, top - 1, false),\n ([40, 0, 60], 3, 100, true),\n ([60, 60, 0], 3, 100, false),\n ([0, 0, 0], 3, 100, true),\n ];\n for row in rows {\n let (weights, num_options, balance, accepted) = row;\n let pol = encode_ballot(weights);\n assert(\n check_coefficient_values_with_balance(pol, balance as Field, num_options) == accepted,\n );\n }\n}\n\n/// The last option of the largest round sits next to the coefficients that must be zero.\n#[test]\nfn test_last_option_of_largest_round_counts() {\n let pol = encode_ballot([0, 0, 0, 0, 0, 0, 0, 0, 0, 7]);\n assert(check_coefficient_values_with_balance(pol, 7, MAX_OPTIONS));\n assert(!check_coefficient_values_with_balance(pol, 6, MAX_OPTIONS));\n}\n\n/// A payload below the options, or in an option the round does not have, is refused.\n#[test]\nfn test_coefficient_outside_the_round_options_fails() {\n let mut below = encode_ballot([1, 0]);\n below.coefficients[0] = 1;\n assert(!check_coefficient_values_with_balance(below, 10, 2));\n\n // Option 3 is the first one that a three-option round does not have.\n assert(!check_coefficient_values_with_balance(encode_ballot([1, 0, 0, 1]), 10, 3));\n}\n\n/// The pair solves the equation for the coefficient `Q_MOD_T - 2 * t`, which is below zero, so\n/// only the coefficient bound refuses it.\n#[test(should_fail)]\nfn test_coefficient_below_zero_is_refused() {\n check_weight(Q_MOD_T - 2 * PLAINTEXT_MODULUS, 1, 2);\n}\n\n/// The weight `t` solves the equation for the coefficient 0 with the quotient `Q_MOD_T`, so only\n/// the weight bound refuses it.\n#[test(should_fail)]\nfn test_weight_outside_range_is_refused() {\n check_weight(0, PLAINTEXT_MODULUS, Q_MOD_T);\n}\n\n/// A weight the coefficient does not carry is refused, also with the quotient of that weight.\n#[test(should_fail)]\nfn test_weight_the_coefficient_does_not_carry_is_refused() {\n let quotient = ((Q_MOD_T as u64) * 6) / (PLAINTEXT_MODULUS as u64);\n check_weight(scale(5), 6, quotient as Field);\n}\n\n/// A quotient outside `[0, t)` solves the equation for any weight, so only the quotient bound\n/// refuses this weight of zero.\n#[test(should_fail)]\nfn test_quotient_outside_range_is_refused() {\n check_weight(scale(5), 0, -scale(5) / PLAINTEXT_MODULUS);\n}\n\n/// A mask must be zero everywhere: in the option coefficients and below them.\n#[test]\nfn test_check_coefficient_zero() {\n assert(check_coefficient_zero(encode_ballot([0, 0]), 3));\n assert(!check_coefficient_zero(encode_ballot([1, 0]), 3));\n\n let mut pol = encode_ballot([0, 0]);\n pol.coefficients[0] = 1;\n assert(!check_coefficient_zero(pol, 3));\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/examples/CRISP/circuits/lib/src/utils.nr", function_locations: [{ start: 925, name: "check_option_count" }, { start: 1897, name: "check_weight" }, { start: 2364, name: "decode_weight_hint" }, { start: 3537, name: "check_coefficient_values_with_balance" }, { start: 4952, name: "check_coefficient_zero" }, { start: 5541, name: "scale" }, { start: 5839, name: "encode_ballot" }, { start: 6180, name: "test_vote_rules" }, { start: 7025, name: "test_last_option_of_largest_round_counts" }, { start: 7384, name: "test_coefficient_outside_the_round_options_fails" }, { start: 7896, name: "test_coefficient_below_zero_is_refused" }, { start: 8152, name: "test_weight_outside_range_is_refused" }, { start: 8381, name: "test_weight_the_coefficient_does_not_carry_is_refused" }, { start: 8701, name: "test_quotient_outside_range_is_refused" }, { start: 8888, name: "test_check_coefficient_zero" }] }, "93": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::helpers::{compute_safe, flatten, flatten_checked};\nuse crate::math::polynomial::Polynomial;\n\n/// DOMAIN SEPARATORS\n\n// Domain separator - "PK"\npub global DS_PK: [u8; 64] = [\n 0x50, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_GENERATION"\npub global DS_PK_GENERATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_COMPUTATION"\npub global DS_SHARE_COMPUTATION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_ENCRYPTION"\npub global DS_SHARE_ENCRYPTION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_AGGREGATION"\npub global DS_PK_AGGREGATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CIPHERTEXT"\npub global DS_CIPHERTEXT: [u8; 64] = [\n 0x43, 0x49, 0x50, 0x48, 0x45, 0x52, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "AGGREGATED_SHARES"\npub global DS_AGGREGATED_SHARES: [u8; 64] = [\n 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45,\n 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "VK_HASH"\npub global DS_VK_HASH: [u8; 64] = [\n 0x56, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "RECURSIVE_AGGREGATION"\npub global DS_RECURSIVE_AGGREGATION: [u8; 64] = [\n 0x52, 0x45, 0x43, 0x55, 0x52, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47,\n 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_PK_GENERATION"\npub global DS_CLG_PK_GENERATION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_ENCRYPTION"\npub global DS_CLG_SHARE_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_USER_DATA_ENCRYPTION"\npub global DS_CLG_USER_DATA_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e,\n 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_DECRYPTION"\npub global DS_CLG_SHARE_DECRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "THRESHOLD_DECRYPTION_SHARE"\npub global DS_THRESHOLD_DECRYPTION_SHARE: [u8; 64] = [\n 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "USER_DATA_ENCRYPTION_COMMITMENT"\npub global DS_USER_DATA_ENCRYPTION_COMMITMENT: [u8; 64] = [\n 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n/// WRAPPERS\n\npub fn compute_commitment(inputs: [Field], domain_separator: [u8; 64]) -> Field {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 1])[0]\n}\n\npub fn compute_single_polynomial_commitment<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_single_polynomial_commitment`] with the digit asserts, for a polynomial this circuit\n/// carries no bound for. ct1 commits `u` this way: ct0 range-checks the same `u` to `u_bound` and the\n/// `user_data_encryption` fold asserts the two `u` commitments are equal, so making ct1\'s packing\n/// injective is what forces its `u` to equal ct0\'s \u2014 the bound transfers instead of being repeated.\n/// Produces the same value as the plain version for any input the plain version could legitimately\n/// have committed.\npub fn compute_single_polynomial_commitment_checked<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_multiple_polynomial_commitment<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_challenge<let L: u32>(inputs: [Field], domain_separator: [u8; 64]) -> [Field] {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 2 * L])\n}\n\npub fn single_polynomial_payload<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\npub fn single_polynomial_payload_checked<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload_checked<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n payload = multiple_polynomial_payload::<N, L, BIT_PK>(payload, pk1);\n\n compute_commitment(payload, DS_PK)\n}\n\npub fn compute_threshold_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\n/// [`compute_multiple_polynomial_commitment`] for a circuit that **opens** this commitment.\npub fn compute_multiple_polynomial_commitment_checked<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_threshold_pk_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C5). Asserts each packed digit fits its slot, which makes the opening unique and so\n/// forces the opened `pk0` to equal the `pk0` C1 committed. Produces the same value as the plain\n/// helper, so C1 needs no change.\npub fn compute_threshold_pk_commitment_checked<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\npub fn compute_share_computation_sk_commitment<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\n/// [`compute_share_computation_sk_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2a). C1 creates it and bounds `sk` to the trinary range, so making the opening\n/// unique forces the witness to equal that `sk`.\npub fn compute_share_computation_sk_commitment_checked<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_computation_e_sm_commitment<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_encryption_commitment_from_message<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\n/// [`compute_share_encryption_commitment_from_message`] for a circuit that **opens** this\n/// commitment rather than creating it (C4). Asserts each packed digit fits its slot, forcing the\n/// opened share to equal the share C2 committed. Same value as the plain helper, so C2 and C3 need\n/// no change.\npub fn compute_share_encryption_commitment_from_message_checked<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\npub fn compute_aggregated_shares_commitment<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// Commitment to a threshold decryption share: all CRT limbs, first `K` coefficients per limb\n/// (same layout as `Polynomial<K>` in decrypted_shares_aggregation).\n///\n/// `NATIVE_BIT_WIDTH` must cover native coefficients in \\([0, q_l)\\) per limb (not centered `d` bounds).\npub fn compute_threshold_decryption_share_commitment<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload =\n multiple_polynomial_payload::<K, L, NATIVE_BIT_WIDTH>([].as_vector(), d_share_limbs);\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_threshold_decryption_share_commitment`] for a circuit that **opens** this commitment\n/// rather than creating it (C7). C6 creates it and pins each coefficient to a native residue in\n/// \\([0, q)\\) via `verify_d_native_trunc_binding`, so asserting the digits here makes the opening\n/// unique and forces the opened share to equal the one C6 committed. Produces the same value as the\n/// plain version for any input the plain version could legitimately have committed.\npub fn compute_threshold_decryption_share_commitment_checked<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<K, L, NATIVE_BIT_WIDTH>(\n [].as_vector(),\n d_share_limbs,\n );\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_share_computation_e_sm_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2b). C1 creates it and bounds each `e_sm` limb to a centered residue.\npub fn compute_share_computation_e_sm_commitment_checked<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_pk_aggregation_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let commit_pk0 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk0, DS_PK_AGGREGATION);\n let commit_pk1 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk1, DS_PK_AGGREGATION);\n\n let inputs = [commit_pk0, commit_pk1].as_vector();\n\n compute_commitment(inputs, DS_PK_AGGREGATION)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: [Field]) -> Field {\n compute_commitment(payload, DS_RECURSIVE_AGGREGATION)\n}\n\npub fn compute_vk_hash(vk_hashes: [Field]) -> Field {\n compute_commitment(vk_hashes, DS_VK_HASH)\n}\n\n/// [`compute_aggregated_shares_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). C4 creates it after `normalize_aggregated` has reduced and centered the\n/// aggregate, so making the opening unique forces the witness to equal that canonical value.\npub fn compute_aggregated_shares_commitment_checked<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// [`compute_ciphertext_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). No upstream circuit bounds the ciphertext limbs, so this buys injectivity\n/// rather than canonicality \u2014 which is the property wanted here: it forces C6 to decrypt exactly\n/// the ciphertext that was committed, whatever its representation.\npub fn compute_ciphertext_commitment_checked<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\npub fn compute_ciphertext_commitment<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: [Field]) -> Field {\n compute_commitment(payload, DS_CLG_PK_GENERATION)\n}\n\npub fn compute_share_encryption_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_SHARE_ENCRYPTION)\n}\n\npub fn compute_threshold_share_decryption_challenge<let L: u32>(payload: [Field]) -> Field {\n compute_challenge::<L>(payload, DS_CLG_SHARE_DECRYPTION)[0]\n}\n\npub fn compute_user_data_encryption_ct0_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n\npub fn compute_user_data_encryption_ct1_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/commitments.nr", function_locations: [{ start: 7784, name: "compute_commitment" }, { start: 8012, name: "compute_single_polynomial_commitment" }, { start: 8827, name: "compute_single_polynomial_commitment_checked" }, { start: 9138, name: "compute_multiple_polynomial_commitment" }, { start: 9375, name: "compute_challenge" }, { start: 9585, name: "single_polynomial_payload" }, { start: 9784, name: "multiple_polynomial_payload" }, { start: 9970, name: "single_polynomial_payload_checked" }, { start: 10185, name: "multiple_polynomial_payload_checked" }, { start: 10406, name: "compute_dkg_pk_commitment" }, { start: 10733, name: "compute_threshold_pk_commitment" }, { start: 11138, name: "compute_multiple_polynomial_commitment_checked" }, { start: 11750, name: "compute_threshold_pk_commitment_checked" }, { start: 12008, name: "compute_share_computation_sk_commitment" }, { start: 12516, name: "compute_share_computation_sk_commitment_checked" }, { start: 12795, name: "compute_share_computation_e_sm_commitment" }, { start: 13067, name: "compute_share_encryption_commitment_from_message" }, { start: 13647, name: "compute_share_encryption_commitment_from_message_checked" }, { start: 13931, name: "compute_aggregated_shares_commitment" }, { start: 14512, name: "compute_threshold_decryption_share_commitment" }, { start: 15336, name: "compute_threshold_decryption_share_commitment_checked" }, { start: 15876, name: "compute_share_computation_e_sm_commitment_checked" }, { start: 16182, name: "compute_pk_aggregation_commitment" }, { start: 16571, name: "compute_recursive_aggregation_commitment" }, { start: 16686, name: "compute_vk_hash" }, { start: 17169, name: "compute_aggregated_shares_commitment_checked" }, { start: 17843, name: "compute_ciphertext_commitment_checked" }, { start: 18325, name: "compute_ciphertext_commitment" }, { start: 18724, name: "compute_threshold_pk_challenge" }, { start: 18866, name: "compute_share_encryption_challenge" }, { start: 19023, name: "compute_threshold_share_decryption_challenge" }, { start: 19183, name: "compute_user_data_encryption_ct0_challenge" }, { start: 19344, name: "compute_user_data_encryption_ct1_challenge" }] }, "95": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Helper functions for circuit construction and cryptographic operations.\nuse crate::math::polynomial::Polynomial;\nuse crate::math::safe::SafeSponge;\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by pack/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout<let BIT: u32>() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n // `group == 1` packs one value per carrier: it saves no sponge absorptions at all while still\n // charging the range checks that make packing injective, so it is always a loss. Measured at\n // BIT=143: +82% gates against absorbing directly. Reject it rather than pay for nothing.\n assert(group >= 2);\n (nibble_bits, group)\n}\n\n/// Like [`pack`], but asserts every digit fits its slot.\n///\n/// ## Why\n/// `pack` builds each carrier as a base-`radix` number, `acc = acc * radix + (v + base)`. That\n/// representation is unique only while every digit stays below `radix`. An unbounded value can\n/// overflow its slot and cancel against the next, so one commitment gains a second opening and a\n/// prover can choose which coefficients it opens to.\n///\n/// `digit < radix` is exactly `digit.assert_max_bit_size::<nibble_bits + 4>()`, and because\n/// `assert_max_bit_size` also forces `digit >= 0`, a single assert gives the whole condition.\n///\n/// ## When to use it\n/// Use this where a circuit **opens** a commitment it did not create. The creating circuit's own\n/// range checks already keep its digits in slot, so asserting the same here forces the opened\n/// coefficients to equal the committed ones \u2014 injectivity transfers the upstream bound without\n/// repeating it. One assert costs about half a two-sided `range_check_2bounds`.\n///\n/// It does **not** replace a bound the protocol requires in its own right, and it gives injectivity,\n/// not canonicality: it pins the opening, not a unique representative modulo `q`. A value that no\n/// upstream circuit bounded still needs its own check (see C1 `pk0` and C5 `pk0_agg`).\n///\n/// ## Compatibility\n/// Adding asserts does not change the packed value, so a commitment created with [`pack`] and\n/// opened with `pack_checked` agree. Adoption is per circuit and needs no commitment change.\npub fn pack_checked<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field);\n let radix = 2.pow_32((nibble_bits + 4) as Field);\n\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n for chunk in 0..num_chunks {\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n let digit = v + base;\n // digit < radix = 2^(nibble_bits + 4): the injectivity condition.\n digit.assert_max_bit_size::<((BIT + 3) / 4) * 4 + 4>();\n acc = acc * radix + digit;\n }\n\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Like [`flatten`], but packs with [`pack_checked`]. Use where a circuit opens a commitment it did\n/// not create.\npub fn flatten_checked<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n let packed = pack_checked::<A, BIT>(poly[j].coefficients);\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n inputs\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `pack::<A, BIT>` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::<BIT>()` and must match what `pack` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::<A, BIT>(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `[Field]` vector of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::<BIT>()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `pack` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::<BIT>()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `[Field]` vector where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Computes a cryptographic hash using the SAFE (Sponge API for Field Elements) protocol.\n///\n/// This is a convenience wrapper around the SAFE sponge API that handles the full\n/// lifecycle: initialization, absorption, squeezing, and finalization. It's designed\n/// for use in Fiat-Shamir challenge generation and commitment schemes within zero-knowledge circuits.\n///\n/// # Arguments\n/// * `domain_separator` - A 64-byte domain separator used to differentiate between\n/// different protocol instances and prevent cross-protocol attacks.\n/// * `inputs` - Vector of field elements to be absorbed into the sponge.\n/// * `io_pattern` - A 2-element array encoding the I/O pattern:\n/// - `io_pattern[0]`: Encoded ABSORB operation (MSB=1, lower 31 bits = length)\n/// - `io_pattern[1]`: Encoded SQUEEZE operation (MSB=0, lower 31 bits = length)\n///\n/// # Returns\n/// A vector of field elements squeezed from the sponge, with length determined by\n/// the SQUEEZE operation in the IO pattern.\n/// Proves `0 <= v < upper` using two one-sided bit-size checks.\n///\n/// `assert_max_bit_size` is one-sided: it forces a small **non-negative** field element. So bounding\n/// `v` gives `v >= 0`, and bounding `upper - 1 - v` gives `v <= upper - 1`. The pair composes into a\n/// two-sided interval without a comparison operator.\n///\n/// `BIT` must cover `upper`; the caller supplies it from the generated config.\npub fn assert_in_range<let BIT: u32>(v: Field, upper: Field) {\n v.assert_max_bit_size::<BIT>();\n (upper - 1 - v).assert_max_bit_size::<BIT>();\n}\n\npub fn compute_safe(domain_separator: [u8; 64], inputs: [Field], io_pattern: [u32; 2]) -> [Field] {\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let digests = sponge.squeeze();\n sponge.finish();\n\n digests\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert(result[0] == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result[1] == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result[2] == 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert(result[0] == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result[1] == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result[2] == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result[3] == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result[4] == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result[5] == 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result[0] == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result[1] == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result[2] == 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n\n#[test]\nfn test_safe_hashing_with_safe_helper() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let digests1 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests1.len() == 1);\n assert(digests1[0] != 0);\n\n // Test determinism\n let digests2 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests2.len() == 1);\n assert(digests2[0] != 0);\n assert(digests2[0] == digests1[0]);\n}\n\n#[test]\nfn test_pack() {\n // Test pack function directly with small values\n let values = [1, 2, 3, 4];\n let packed = pack::<4, 4>(values);\n\n // With BIT=4, nibble_bits=4, group should be floor(254/(4+4)) = 31\n // So all 4 values should fit in one carrier\n assert(packed.len() >= 1);\n\n // Test with negative values\n let values_neg = [-1, 2, -3, 4];\n let packed_neg = pack::<4, 4>(values_neg);\n assert(packed_neg.len() >= 1);\n}\n\n#[test]\nfn test_pack_single_value() {\n // Test packing a single value\n let values = [42];\n let packed = pack::<1, 8>(values);\n assert(packed.len() == 1);\n assert(packed[0] != 0);\n}\n\n#[test]\nfn test_pack_determinism() {\n // Test that packing is deterministic\n let values = [10, 20, 30];\n let packed1 = pack::<3, 8>(values);\n let packed2 = pack::<3, 8>(values);\n\n assert(packed1.len() == packed2.len());\n for i in 0..packed1.len() {\n assert(packed1[i] == packed2[i]);\n }\n}\n\n/// `pack_checked` must agree with `pack` for in-slot values. The two carry duplicate layout\n/// arithmetic, so if one is changed without the other, a commitment created by a circuit on `pack`\n/// stops matching one opened by a circuit on `pack_checked`. This pins that.\n#[test]\nfn test_pack_checked_matches_pack() {\n // Mixed signs, and values at the edge of the centred window for BIT = 35 (slot = 2^40).\n let vals: [Field; 7] = [0, 1, -1, 34359701504, -34359701504, 12345, -6789];\n let plain = pack::<7, 35>(vals);\n let checked = pack_checked::<7, 35>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n\n/// Same, at a width whose chunking leaves a partial final carrier (BIT = 57 -> group 3, 7 values).\n#[test]\nfn test_pack_checked_matches_pack_partial_chunk() {\n let vals: [Field; 7] = [5, -5, 72057594049265664, -72057594049265664, 1, 0, -1];\n let plain = pack::<7, 57>(vals);\n let checked = pack_checked::<7, 57>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/helpers.nr", function_locations: [{ start: 1374, name: "packing_layout" }, { start: 3703, name: "pack_checked" }, { start: 4808, name: "flatten_checked" }, { start: 6096, name: "flatten" }, { start: 7946, name: "pack" }, { start: 10581, name: "assert_in_range" }, { start: 10770, name: "compute_safe" }, { start: 10968, name: "test_flatten" }, { start: 11911, name: "test_flatten_big" }, { start: 14812, name: "test_flatten_small" }, { start: 15639, name: "test_safe_hashing_with_safe_helper" }, { start: 16485, name: "test_pack" }, { start: 16955, name: "test_pack_single_value" }, { start: 17151, name: "test_pack_determinism" }, { start: 17749, name: "test_pack_checked_matches_pack" }, { start: 18287, name: "test_pack_checked_matches_pack_partial_chunk" }] }, "100": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Unconstrained functions for modular u128 arithmetic.\n//!\n//! This module provides unconstrained functions that perform modular arithmetic\n//! computations without generating circuit constraints. These functions are used\n//! internally by the constrained operations in `U128` and should not be called\n//! directly in circuits without proper verification.\n\n/// Computes quotient and remainder for value modulo q (unconstrained).\n///\n/// This function performs integer division and modulo operations to compute\n/// `value = q * quotient + remainder` where `0 <= remainder < q`.\n///\n/// # Arguments\n/// * `value` - The value to reduce\n/// * `q` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where:\n/// - `quotient = value / q`\n/// - `remainder = value % q`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __compute_mod_reduction(value: Field, q: Field) -> (Field, Field) {\n let value_u128 = value as u128;\n let q_u128 = q as u128;\n\n let quotient_u128 = value_u128 / q_u128;\n let remainder_u128 = value_u128 % q_u128;\n\n (quotient_u128 as Field, remainder_u128 as Field)\n}\n\n/// Computes the negation of a value modulo m (unconstrained).\n///\n/// Returns `(m - val) mod m`, with special handling for zero (returns 0).\n///\n/// # Arguments\n/// * `val` - The value to negate\n/// * `m` - The modulus\n///\n/// # Returns\n/// The additive inverse `(-val) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __neg(val: Field, m: Field) -> Field {\n if val == 0 {\n 0\n } else {\n m - val\n }\n}\n\n/// Subtracts two values with underflow handling (unconstrained).\n///\n/// Computes `(lhs - rhs) mod m`, handling the case where `lhs < rhs` by adding\n/// the modulus. Returns both the result and a flag indicating if underflow occurred.\n///\n/// # Preconditions\n/// Inputs must be reduced modulo `m` such that `lhs, rhs in [0, m)`. This ensures\n/// that the computed difference is bounded and cannot overflow `u128`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value (minuend), must be in `[0, m)`\n/// * `rhs` - Right-hand side value (subtrahend), must be in `[0, m)`\n/// * `m` - The modulus, must satisfy `m <= u128::MAX`\n///\n/// # Returns\n/// A tuple `(result, underflow)` where:\n/// - `result = (lhs - rhs) mod m`\n/// - `underflow = true` if `lhs < rhs`, `false` otherwise\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// As long as inputs are reduced modulo `m` (and `m <= u128::MAX`), the subtraction-with-underflow\n/// logic is safe and will not overflow `u128`. This function is used by the constrained `sub` method\n/// in `modulo::U128`, which ensures inputs are properly reduced before calling `__sub_with_underflow`.\n/// See the surrounding `modulo/unconstrained_U128` module documentation for details.\npub unconstrained fn __sub_with_underflow(lhs: Field, rhs: Field, m: Field) -> (Field, bool) {\n let lhs_u128 = lhs as u128;\n let rhs_u128 = rhs as u128;\n let m_u128 = m as u128;\n\n let underflow = lhs_u128 < rhs_u128;\n let result = if underflow {\n // Compute (lhs - rhs + m) mod m safely to avoid u128 overflow\n // Since lhs < rhs, we compute: m - (rhs - lhs)\n // This avoids the potential overflow in lhs + m\n let diff = rhs_u128 - lhs_u128; // This is safe since rhs > lhs\n (m_u128 - diff) as Field\n } else {\n (lhs_u128 - rhs_u128) as Field\n };\n (result, underflow)\n}\n\n/// Multiplies two values and returns both quotient and remainder (unconstrained).\n///\n/// Computes `lhs * rhs = m * quotient + remainder` where `0 <= remainder < m`.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// A tuple `(quotient, remainder)` where `lhs * rhs = m * quotient + remainder`\n///\n/// # Overflow Warning\n/// Field multiplication wraps modulo the field prime (~254 bits). For two u128 values\n/// near 2^128, their product (up to 2^256) exceeds the Field modulus, causing silent\n/// wraparound before the mod reduction. This can produce incorrect results.\n///\n/// # Safe Input Range\n/// To avoid overflow, ensure `lhs * rhs < Field::MODULUS`. For typical use cases:\n/// - Party IDs, polynomial coefficients, and small cryptographic values (< 2^64) are safe\n/// - Arbitrary u128 values may overflow and should be validated by callers\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\n/// Callers must ensure inputs are within the safe range to prevent silent overflow.\npub unconstrained fn __mul_with_quotient(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n // WARNING: Field multiplication can overflow for large inputs.\n // For u128 values near 2^128, the product (up to 2^256) exceeds Field modulus (~2^254),\n // causing wraparound. This is safe for typical use cases (party IDs, small coefficients),\n // but callers must validate input ranges for arbitrary u128 values.\n let product = lhs * rhs;\n __compute_mod_reduction(product, m)\n}\n\n/// Multiplies lhs and rhs via u128 arithmetic, returning (quotient, remainder).\n///\n/// Safe when lhs, rhs < 2^62: product < 2^124, fits in u128 without wrapping.\n/// Prefer this over `__mul_with_quotient` when inputs are known to be < 2^62 (i.e. when\n/// the modulus is < 2^62), as it avoids silent Field-prime wraparound.\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_with_quotient_u128(lhs: Field, rhs: Field, m: Field) -> (Field, Field) {\n let product = lhs as u128 * rhs as u128; // safe: inputs < 2^62, product < 2^124\n let q = m as u128;\n ((product / q) as Field, (product % q) as Field)\n}\n\n/// Computes the modular multiplicative inverse using Fermat's Little Theorem (unconstrained).\n///\n/// For a prime modulus `m` and value `val` coprime to `m`, computes `val^(-1) mod m`\n/// using the identity: val^(-1) = val^(m-2) (mod m) (from Fermat's Little Theorem).\n///\n/// # Arguments\n/// * `val` - The value to invert (must be coprime with the modulus)\n/// * `m` - The modulus (should be prime for this method to work correctly)\n///\n/// # Returns\n/// The modular inverse `val^(-1) mod m` such that `(val * result) mod m = 1`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __inv_mod(val: Field, m: Field) -> Field {\n // by Fermat's Little Theorem: val^(m-1)= 1 mod m\n __pow_mod(val, m - 2, m)\n}\n\n/// Computes modular division: `lhs * rhs^(-1) mod m` (unconstrained).\n///\n/// This is equivalent to multiplying `lhs` by the modular inverse of `rhs`.\n///\n/// # Arguments\n/// * `lhs` - The numerator\n/// * `rhs` - The denominator (must be coprime with the modulus)\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs^(-1)) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __div_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let rhs_inv = __inv_mod(rhs, m);\n __mul_mod(lhs, rhs_inv, m)\n}\n\n/// Computes modular exponentiation: `base^exp mod m` (unconstrained).\n///\n/// Uses the binary exponentiation method (also known as square-and-multiply)\n/// for efficient computation of large powers.\n///\n/// # Arguments\n/// * `base` - The base value\n/// * `exp` - The exponent\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `base^exp mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __pow_mod(base: Field, exp: Field, m: Field) -> Field {\n let mut result = 1 as Field;\n let (_, base_mod) = __compute_mod_reduction(base, m);\n let mut current_base = base_mod;\n let mut e = exp as u128;\n\n while e > 0 {\n if (e % 2) == 1 {\n result = __mul_mod(result, current_base, m);\n }\n current_base = __mul_mod(current_base, current_base, m);\n e = e / 2;\n }\n\n result\n}\n\n/// Multiplies two values with modular reduction (unconstrained).\n///\n/// Computes `(lhs * rhs) mod m` and returns only the remainder.\n///\n/// # Arguments\n/// * `lhs` - Left-hand side value\n/// * `rhs` - Right-hand side value\n/// * `m` - The modulus\n///\n/// # Returns\n/// The result of `(lhs * rhs) mod m`\n///\n/// # Safety\n/// This is an unconstrained function. The result must be verified in constrained code.\npub unconstrained fn __mul_mod(lhs: Field, rhs: Field, m: Field) -> Field {\n let (_, r) = __mul_with_quotient(lhs, rhs, m);\n r\n}\n\n// ------------------------------ TESTS ------------------------------\n// Note: All unsafe blocks in the following tests are safe because we are testing\n// unconstrained functions in a controlled test environment. These functions are\n// designed to be called from unsafe blocks or other unconstrained functions.\n// Each unsafe block is used to call an unconstrained function for testing purposes.\n\n#[test]\nfn test_compute_mod_reduction_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(42, 10) };\n assert(q == 4); // 42 / 10 = 4\n assert(r == 2); // 42 % 10 = 2\n // Verify: 42 = 10 * 4 + 2\n assert(10 * q + r == 42);\n}\n\n#[test]\nfn test_compute_mod_reduction_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(100, 10) };\n assert(q == 10); // 100 / 10 = 10\n assert(r == 0); // 100 % 10 = 0\n assert(10 * q + r == 100);\n}\n\n#[test]\nfn test_compute_mod_reduction_large_value() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(12345, 100) };\n assert(q == 123); // 12345 / 100 = 123\n assert(r == 45); // 12345 % 100 = 45\n assert(100 * q + r == 12345);\n}\n\n#[test]\nfn test_compute_mod_reduction_smaller_than_modulus() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __compute_mod_reduction(7, 10) };\n assert(q == 0); // 7 / 10 = 0\n assert(r == 7); // 7 % 10 = 7\n assert(10 * q + r == 7);\n}\n\n#[test]\nfn test_neg_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(0, 100) };\n assert(result == 0); // Negation of zero is zero\n}\n\n#[test]\nfn test_neg_non_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(30, 100) };\n assert(result == 70); // 100 - 30 = 70\n}\n\n#[test]\nfn test_neg_large_value() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __neg(12345, 100000) };\n assert(result == 87655); // 100000 - 12345 = 87655\n}\n\n#[test]\nfn test_neg_verification() {\n let val: Field = 42;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let neg_val = unsafe { __neg(val, m) };\n // Verify: val + neg_val = 0 (mod m)\n let sum = val + neg_val;\n // Safety: Test function calling unconstrained helper\n let (_, remainder) = unsafe { __compute_mod_reduction(sum, m) };\n assert(remainder == 0);\n}\n\n#[test]\nfn test_sub_with_underflow_no_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(50, 30, 100) };\n assert(underflow == false);\n assert(result == 20); // 50 - 30 = 20\n}\n\n#[test]\nfn test_sub_with_underflow_with_underflow() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(30, 50, 100) };\n assert(underflow == true);\n assert(result == 80); // (30 - 50 + 100) mod 100 = 80\n}\n\n#[test]\nfn test_sub_with_underflow_equal_values() {\n // Safety: Test function calling unconstrained helper\n let (result, underflow) = unsafe { __sub_with_underflow(42, 42, 100) };\n assert(underflow == false);\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_with_quotient_simple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(6, 7, 10) };\n assert(q == 4); // (6 * 7) / 10 = 42 / 10 = 4\n assert(r == 2); // (6 * 7) % 10 = 42 % 10 = 2\n // Verify: 6 * 7 = 10 * 4 + 2\n assert(6 * 7 == 10 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(12, 15, 100) };\n assert(q == 1); // (12 * 15) / 100 = 180 / 100 = 1\n assert(r == 80); // (12 * 15) % 100 = 180 % 100 = 80\n assert(12 * 15 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(5, 20, 100) };\n assert(q == 1); // (5 * 20) / 100 = 100 / 100 = 1\n assert(r == 0); // (5 * 20) % 100 = 100 % 100 = 0\n assert(5 * 20 == 100 * q + r);\n}\n\n#[test]\nfn test_mul_with_quotient_verification() {\n let lhs: Field = 123;\n let rhs: Field = 456;\n let m: Field = 1000;\n // Safety: Test function calling unconstrained helper\n let (q, r) = unsafe { __mul_with_quotient(lhs, rhs, m) };\n // Verify: lhs * rhs = m * q + r\n assert(lhs * rhs == m * q + r);\n // Verify remainder is in range [0, m)\n assert((r as u128) < (m as u128));\n}\n\n#[test]\nfn test_mul_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(6, 7, 10) };\n assert(result == 2); // (6 * 7) mod 10 = 42 mod 10 = 2\n}\n\n#[test]\nfn test_mul_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(12, 15, 100) };\n assert(result == 80); // (12 * 15) mod 100 = 180 mod 100 = 80\n}\n\n#[test]\nfn test_mul_mod_exact_multiple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(5, 20, 100) };\n assert(result == 0); // (5 * 20) mod 100 = 100 mod 100 = 0\n}\n\n#[test]\nfn test_mul_mod_with_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __mul_mod(42, 0, 100) };\n assert(result == 0);\n}\n\n#[test]\nfn test_mul_mod_commutative() {\n let a: Field = 7;\n let b: Field = 9;\n let m: Field = 100;\n // Safety: Test function calling unconstrained helper\n let mul_a_b = unsafe { __mul_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n let mul_b_a = unsafe { __mul_mod(b, a, m) };\n // Verify: a * b = b * a\n assert(mul_a_b == mul_b_a);\n}\n\n#[test]\nfn test_pow_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 3, 10) };\n assert(result == 8); // 2^3 mod 10 = 8 mod 10 = 8\n}\n\n#[test]\nfn test_pow_mod_with_reduction() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(2, 10, 100) };\n assert(result == 24); // 2^10 = 1024, 1024 mod 100 = 24\n}\n\n#[test]\nfn test_pow_mod_exponent_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 1, 100) };\n assert(result == 7); // 7^1 mod 100 = 7\n}\n\n#[test]\nfn test_pow_mod_exponent_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(7, 0, 100) };\n assert(result == 1); // 7^0 mod 100 = 1\n}\n\n#[test]\nfn test_pow_mod_base_zero() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(0, 5, 100) };\n assert(result == 0); // 0^5 mod 100 = 0\n}\n\n#[test]\nfn test_pow_mod_large_exponent() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(3, 7, 97) };\n // 3^7 = 2187, 2187 mod 97 = 53\n assert(result == 53);\n}\n\n#[test]\nfn test_pow_mod_fermat_little_theorem() {\n // For prime modulus p and value a, a^(p-1) = 1 (mod p)\n let a: Field = 3;\n let p: Field = 11; // Prime\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __pow_mod(a, p - 1, p) };\n assert(result == 1);\n}\n\n#[test]\nfn test_inv_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(3, 11) };\n // 3 * 4 = 12 = 1 (mod 11), so 3^(-1) = 4 (mod 11)\n assert(result == 4);\n // Verify: 3 * result = 1 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(3, result, 11) } == 1);\n}\n\n#[test]\nfn test_inv_mod_larger_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(7, 13) };\n // Verify: 7 * result = 1 (mod 13)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(7, result, 13) } == 1);\n}\n\n#[test]\nfn test_inv_mod_another_prime() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __inv_mod(5, 17) };\n // Verify: 5 * result = 1 (mod 17)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(5, result, 17) } == 1);\n}\n\n#[test]\nfn test_inv_mod_inverse_of_inverse() {\n let a: Field = 7;\n let m: Field = 11;\n // Safety: Test function calling unconstrained helper\n let inv_a = unsafe { __inv_mod(a, m) };\n // Safety: Test function calling unconstrained helper\n let inv_inv_a = unsafe { __inv_mod(inv_a, m) };\n // (a^(-1))^(-1) = a\n assert(inv_inv_a == a);\n}\n\n#[test]\nfn test_div_mod_simple() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(6, 2, 11) };\n assert(result == 3); // 6 / 2 = 3\n // Verify: result * 2 = 6 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 2, 11) } == 6);\n}\n\n#[test]\nfn test_div_mod_with_inverse() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(7, 3, 11) };\n // 3^(-1) mod 11 = 4 (since 3 * 4 = 12 = 1 mod 11)\n // 7 * 4 = 28 = 6 (mod 11)\n assert(result == 6);\n // Verify: result * 3 = 7 (mod 11)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 3, 11) } == 7);\n}\n\n#[test]\nfn test_div_mod_verification() {\n let a: Field = 10;\n let b: Field = 3;\n let m: Field = 17;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a);\n}\n\n#[test]\nfn test_div_mod_larger_values() {\n let a: Field = 250;\n let b: Field = 7;\n let m: Field = 97;\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(a, b, m) };\n // Verify: result * b = a (mod m)\n // Safety: Test function calling unconstrained helper\n let (_, a_reduced) = unsafe { __compute_mod_reduction(a, m) }; // 250 mod 97 = 56\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, b, m) } == a_reduced);\n}\n\n#[test]\nfn test_div_mod_by_one() {\n // Safety: Test function calling unconstrained helper\n let result = unsafe { __div_mod(42, 1, 100) };\n assert(result == 42); // 42 / 1 = 42\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(result, 1, 100) } == 42);\n}\n\n#[test]\nfn test_all_operations_consistency() {\n // Test that all operations work together correctly\n let m: Field = 97; // Prime\n let a: Field = 42;\n let b: Field = 13;\n\n // Test: (a + b) mod m\n let sum = a + b;\n // Safety: Test function calling unconstrained helper\n let (_, sum_reduced) = unsafe { __compute_mod_reduction(sum, m) };\n assert(sum_reduced == 55);\n\n // Test: (a - b) mod m using subtraction\n // Safety: Test function calling unconstrained helper\n let (diff, _) = unsafe { __sub_with_underflow(a, b, m) };\n assert(diff == 29);\n\n // Test: (a * b) mod m\n // Safety: Test function calling unconstrained helper\n let prod = unsafe { __mul_mod(a, b, m) };\n assert(prod == 61); // (42 * 13) mod 97 = 546 mod 97 = 61\n\n // Test: b^(-1) mod m\n // Safety: Test function calling unconstrained helper\n let inv = unsafe { __inv_mod(b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(b, inv, m) } == 1);\n\n // Test: (a / b) mod m\n // Safety: Test function calling unconstrained helper\n let quot = unsafe { __div_mod(a, b, m) };\n // Safety: Test function calling unconstrained helper\n assert(unsafe { __mul_mod(quot, b, m) } == a);\n\n // Test: (-a) mod m\n // Safety: Test function calling unconstrained helper\n let neg = unsafe { __neg(a, m) };\n let sum_neg = a + neg;\n // Safety: Test function calling unconstrained helper\n let (_, sum_neg_reduced) = unsafe { __compute_mod_reduction(sum_neg, m) };\n assert(sum_neg_reduced == 0);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/modulo/unconstrained_U128.nr", function_locations: [{ start: 1160, name: "__compute_mod_reduction" }, { start: 1817, name: "__neg" }, { start: 3254, name: "__sub_with_underflow" }, { start: 5015, name: "__mul_with_quotient" }, { start: 5946, name: "__mul_with_quotient_u128" }, { start: 6810, name: "__inv_mod" }, { start: 7427, name: "__div_mod" }, { start: 8034, name: "__pow_mod" }, { start: 8895, name: "__mul_mod" }, { start: 9402, name: "test_compute_mod_reduction_simple" }, { start: 9712, name: "test_compute_mod_reduction_exact_multiple" }, { start: 9994, name: "test_compute_mod_reduction_large_value" }, { start: 10301, name: "test_compute_mod_reduction_smaller_than_modulus" }, { start: 10548, name: "test_neg_zero" }, { start: 10738, name: "test_neg_non_zero" }, { start: 10922, name: "test_neg_large_value" }, { start: 11125, name: "test_neg_verification" }, { start: 11555, name: "test_sub_with_underflow_no_underflow" }, { start: 11820, name: "test_sub_with_underflow_with_underflow" }, { start: 12098, name: "test_sub_with_underflow_equal_values" }, { start: 12337, name: "test_mul_with_quotient_simple" }, { start: 12677, name: "test_mul_with_quotient_with_reduction" }, { start: 13001, name: "test_mul_with_quotient_exact_multiple" }, { start: 13317, name: "test_mul_with_quotient_verification" }, { start: 13707, name: "test_mul_mod_simple" }, { start: 13919, name: "test_mul_mod_with_reduction" }, { start: 14141, name: "test_mul_mod_exact_multiple" }, { start: 14354, name: "test_mul_mod_with_zero" }, { start: 14531, name: "test_mul_mod_commutative" }, { start: 14912, name: "test_pow_mod_simple" }, { start: 15119, name: "test_pow_mod_with_reduction" }, { start: 15332, name: "test_pow_mod_exponent_one" }, { start: 15529, name: "test_pow_mod_exponent_zero" }, { start: 15722, name: "test_pow_mod_base_zero" }, { start: 15920, name: "test_pow_mod_large_exponent" }, { start: 16142, name: "test_pow_mod_fermat_little_theorem" }, { start: 16429, name: "test_inv_mod_simple" }, { start: 16808, name: "test_inv_mod_larger_prime" }, { start: 17108, name: "test_inv_mod_another_prime" }, { start: 17413, name: "test_inv_mod_inverse_of_inverse" }, { start: 17761, name: "test_div_mod_simple" }, { start: 18101, name: "test_div_mod_with_inverse" }, { start: 18514, name: "test_div_mod_verification" }, { start: 18882, name: "test_div_mod_larger_values" }, { start: 19396, name: "test_div_mod_by_one" }, { start: 19710, name: "test_all_operations_consistency" }] }, "102": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse super::modulo::U128::ModU128;\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial<let N: u32> {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl<let N: u32> Polynomial<N> {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n /// Inner product of the coefficients with `k`, in the same index order.\n ///\n /// Paired with [`negacyclic_kernel`] this evaluates a product modulo `X^N + 1` without the\n /// product itself entering the witness.\n pub fn dot(self, k: [Field; N]) -> Field {\n let mut out: Field = 0;\n for j in 0..N {\n out += self.coefficients[j] * k[j];\n }\n out\n }\n\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point with modular reduction.\n ///\n /// This function computes `P(x) mod q` using Horner's method with intermediate\n /// modular reductions to prevent overflow. The result is guaranteed to be in\n /// the range `[0, q)`.\n ///\n /// The function performs modular reduction after each multiplication and addition\n /// to ensure the accumulator always remains in the range `[0, q)`, preventing\n /// any potential overflow issues.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial\n /// * `q` - The modular arithmetic context containing the modulus\n ///\n /// # Returns\n /// The value `P(x) mod q` in the range `[0, q)`\n pub fn eval_mod(self, x: Field, q: ModU128) -> Field {\n let mut acc = self.coefficients[0];\n let len = self.coefficients.len();\n\n for i in 1..len {\n acc = q.mul_mod(acc, x);\n acc = q.add(acc, self.coefficients[i]);\n }\n\n acc\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds.\n ///\n /// This function constrains all polynomial coefficients to be in the range [-lower_bound, upper_bound],\n /// where `lower_bound` is a non-negative magnitude.\n /// It uses a shifting technique to handle negative numbers efficiently:\n /// 1. Shifts each coefficient by adding `lower_bound`: c' = c + lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound + lower_bound] using bit-size assertions\n /// 3. This ensures original coefficients are in [-lower_bound, upper_bound]\n ///\n /// The function uses two bit-size checks per coefficient to ensure the value is within bounds:\n /// - `shifted_coefficient.assert_max_bit_size::<BIT + 1>()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>()` ensures c' <= range_size\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - Non-negative magnitude of the negative bound\n /// Coefficients must satisfy: -lower_bound <= c <= upper_bound\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length of the total range `upper_bound + lower_bound`\n /// (choose `BIT` so `upper_bound + lower_bound < 2^BIT`). Since all checked\n /// values lie in `[0, upper_bound + lower_bound]`, they cannot exceed `BIT + 1` bits.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the specified bounds.\n pub fn range_check_2bounds<let BIT: u32>(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::<BIT + 1>();\n (range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, upper_bound).\n ///\n /// This function constrains all polynomial coefficients to be non-negative and\n /// strictly less than `upper_bound`. It uses bit-size assertions to verify that\n /// coefficients are in the valid range.\n ///\n /// The function performs two checks per coefficient:\n /// 1. `coeff.assert_max_bit_size::<BIT>()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::<BIT>()` ensures `coeff < upper_bound`\n ///\n /// # Arguments\n /// * `upper_bound` - The exclusive upper bound for coefficient range checking.\n /// Coefficients must satisfy: `0 <= c < upper_bound`\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Must satisfy `upper_bound <= 2^BIT` for\n /// the range check to work correctly.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, upper_bound)`.\n pub fn range_check_standard<let BIT: u32>(self, upper_bound: Field) {\n for i in 0..self.coefficients.len() {\n let coeff = self.coefficients[i];\n // Check coeff >= 0 and coeff < 2^BIT\n coeff.assert_max_bit_size::<BIT>();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::<BIT>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, 2^BIT).\n ///\n /// This is a specialized range check for coefficients that must be non-negative\n /// and less than a power of two. It's more efficient than `range_check_standard`\n /// when the upper bound is exactly `2^BIT` because it only needs a single\n /// bit-size assertion per coefficient.\n ///\n /// The function verifies that each coefficient satisfies:\n /// - `coeff >= 0` (implicit from bit-size check)\n /// - `coeff < 2^BIT` (enforced by `assert_max_bit_size::<BIT>()`)\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Coefficients must satisfy: `0 <= c < 2^BIT`\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, 2^BIT)`.\n pub fn range_check_power_of_two<let BIT: u32>(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::<BIT>();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert(result == 0);\n}\n\n/// Evaluation kernel for `u` modulo `X^N + 1`: `out[j]` is `(X^(N-1-j) * u mod X^N + 1)(x)`.\n///\n/// `a.dot(negacyclic_kernel(u, x))` then equals `(a * u mod X^N + 1)(x)` without the prover\n/// supplying the product, so no product witness has to be bound or range-checked.\npub fn negacyclic_kernel<let N: u32>(u: Polynomial<N>, x: Field) -> [Field; N] {\n assert(N > 0);\n let phi = x.pow_32(N as Field) + 1;\n let mut out = [0; N];\n out[N - 1] = u.eval(x);\n for j in 1..N {\n out[N - 1 - j] = x * out[N - j] - phi * u.coefficients[j - 1];\n }\n out\n}\n\n#[test]\nfn test_negacyclic_kernel_matches_reduced_product() {\n let a = Polynomial::new([4, 3, 2, 1]);\n let u = Polynomial::new([-1, 0, 1, -1]);\n\n // Schoolbook product, then reduced by hand with X^4 = -1.\n let mut prod = [0; 7];\n for i in 0..4 {\n for j in 0..4 {\n prod[i + j] += a.coefficients[i] * u.coefficients[j];\n }\n }\n let reduced = Polynomial::new([prod[3], prod[4] - prod[0], prod[5] - prod[1], prod[6] - prod[2]]);\n\n let points: [Field; 4] = [0, 1, 2, 17];\n for j in 0..4 {\n let x = points[j];\n assert(a.dot(negacyclic_kernel(u, x)) == reduced.eval(x));\n }\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_polynomial_add() {\n let coeffs1 = [1, 2, 3]; // 1x^2 + 2x + 3\n let coeffs2 = [4, 5, 6]; // 4x^2 + 5x + 6\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.add(poly2);\n\n // Expected: (1+4)x^2 + (2+5)x + (3+6) = 5x^2 + 7x + 9\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 7);\n assert(result.coefficients[2] == 9);\n}\n\n#[test]\nfn test_polynomial_sub() {\n let coeffs1 = [5, 7, 9]; // 5x^2 + 7x + 9\n let coeffs2 = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.sub(poly2);\n\n // Expected: (5-1)x^2 + (7-2)x + (9-3) = 4x^2 + 5x + 6\n assert(result.coefficients[0] == 4);\n assert(result.coefficients[1] == 5);\n assert(result.coefficients[2] == 6);\n}\n\n#[test]\nfn test_polynomial_mul_scalar() {\n let coeffs = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n let scalar = 5;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 5x^2 + 10x + 15\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 10);\n assert(result.coefficients[2] == 15);\n}\n\n#[test]\nfn test_polynomial_mul_scalar_zero() {\n let coeffs = [1, 2, 3];\n let poly = Polynomial::new(coeffs);\n let scalar = 0;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 0x^2 + 0x + 0 = 0\n assert(result.coefficients[0] == 0);\n assert(result.coefficients[1] == 0);\n assert(result.coefficients[2] == 0);\n}\n\n#[test]\nfn test_eval_mod_simple() {\n // Test without initial reduction - simple case\n // p(x) = x + 1 at x=5od 7\n // Expected: (5 + 1) mod 7 = 6\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 1]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 6);\n\n // Test: p(x) = 2x + 3 at x=5od 7\n // Expected: (10 + 3) mod 7 = 13 mod 7 = 6\n let poly2 = Polynomial::new([2, 3]);\n let result2 = poly2.eval_mod(5, q);\n assert(result2 == 6);\n}\n\n#[test]\nfn test_eval_mod() {\n // Test 1: Simple polynomial x^2 + 2x + 3 at x=5od 7\n // Expected: (25 + 10 + 3) mod 7 = 38 mod 7 = 3\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 2, 3]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 3);\n\n // Test 2: Higher degree polynomialod small prime\n // p(x) = x^3 + x^2 + x + 1 at x=2od 11\n // Expected: (8 + 4 + 2 + 1) mod 11 = 15 mod 11 = 4\n let q = ModU128::new(11);\n\n let poly2 = Polynomial::new([1, 1, 1, 1]);\n let result2 = poly2.eval_mod(2, q);\n assert(result2 == 4);\n\n // Test 3: Polynomial with larger coefficients\n // p(x) = 100x^2 + 50x + 25 at x=10od 73\n // Expected: (10000 + 500 + 25) mod 73 = 10525 mod 73 = 13\n let q = ModU128::new(73);\n\n let poly3 = Polynomial::new([100, 50, 25]);\n let result3 = poly3.eval_mod(10, q);\n assert(result3 == 13);\n\n // Test 4: Result should be less than modulus\n let poly4 = Polynomial::new([5, 3, 7]);\n let q = ModU128::new(17);\n let result4 = poly4.eval_mod(4, q);\n assert(result4 as u128 < q.get_mod_field() as u128);\n\n // Test 5: Compare with regular eval for small values\n let poly5 = Polynomial::new([1, 2, 1]);\n let x = 3;\n let q = ModU128::new(1000);\n let result5 = poly5.eval_mod(x, q);\n let expected5 = poly5.eval(x);\n assert(result5 == expected5);\n\n // Test 6: Zero polynomial\n let poly6 = Polynomial::new([0, 0, 0]);\n let q = ModU128::new(13);\n let result6 = poly6.eval_mod(100, q);\n assert(result6 == 0);\n}\n\n#[test]\nfn test_large_party_ids_scenario() {\n // Simulating party IDs in range [1, 100]\n let party_id_1 = 42;\n let party_id_2 = 73;\n let m = ModU128::new(288230376151711717); // ~58 bits\n\n // Operations that would be used in Lagrange coefficients\n let product = m.mul_mod(party_id_1, party_id_2);\n let diff = m.sub(party_id_2, party_id_1);\n\n assert(product == 3066);\n assert(diff == 31);\n}\n\n#[test]\nfn test_eval_vs_eval_mod() {\n // Compare eval and eval_mod for small values where no reduction should occur\n let poly = Polynomial::new([1, 2, 3]);\n let x = 2;\n let q = ModU128::new(1000); // Large enough that no reduction happens\n\n let result_normal = poly.eval(x);\n let result_mod = poly.eval_mod(x, q);\n\n // They should be equal: (1)*2 + 2)*2 + 3 = (2+2)*2 + 3 = 4*2 + 3 = 11\n assert(result_normal == 11);\n assert(result_mod == 11);\n}\n", path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/polynomial.nr", function_locations: [{ start: 1261, name: "Polynomial<N>::new" }, { start: 1555, name: "Polynomial<N>::add" }, { start: 2008, name: "Polynomial<N>::sub" }, { start: 2481, name: "Polynomial<N>::mul_scalar" }, { start: 3426, name: "Polynomial<N>::dot" }, { start: 3602, name: "Polynomial<N>::eval" }, { start: 4576, name: "Polynomial<N>::eval_mod" }, { start: 6506, name: "Polynomial<N>::range_check_2bounds" }, { start: 7992, name: "Polynomial<N>::range_check_standard" }, { start: 9247, name: "Polynomial<N>::range_check_power_of_two" }, { start: 9416, name: "test_polynomial_eval_zero" }, { start: 9976, name: "negacyclic_kernel" }, { start: 10259, name: "test_negacyclic_kernel_matches_reduced_product" }, { start: 10873, name: "test_polynomial_bounds" }, { start: 11156, name: "test_polynomial_out_of_bounds_coefficients" }, { start: 11411, name: "test_polynomial_add" }, { start: 11844, name: "test_polynomial_sub" }, { start: 12284, name: "test_polynomial_mul_scalar" }, { start: 12641, name: "test_polynomial_mul_scalar_zero" }, { start: 12970, name: "test_eval_mod_simple" }, { start: 13450, name: "test_eval_mod" }, { start: 15008, name: "test_large_party_ids_scenario" }, { start: 15418, name: "test_eval_vs_eval_mod" }] }, "104": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\nuse poseidon::poseidon2_permutation;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// "SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge<let L: u32> {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl<let L: u32> SafeSponge<L> {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge<L> {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: [Field]) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, "Expected ABSORB operation");\n assert(expected_length == length, "Length mismatch");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input[i];\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> [Field] {\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, "Expected SQUEEZE operation");\n\n let mut output: [Field] = [].as_vector();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won\'t execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output = output.push_back(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, "IO pattern not completed");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge\'s usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag<let L: u32>(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Buffer is 256 bytes: max 192 bytes for IO pattern (48 words) + 64 bytes for domain separator.\n // Note: We must use a fixed-size array because Noir\'s keccak256 requires [u8; N], not [u8].\n let max_io_pattern_bytes: u32 = 192; // 256 - 64 (domain separator)\n let io_pattern_bytes = word_count * 4;\n assert(\n io_pattern_bytes <= max_io_pattern_bytes,\n "IO pattern too large: max 48 aggregated words supported",\n );\n\n let mut input_bytes = [0u8; 256];\n let mut byte_count: u32 = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n // Note: Noir requires compile-time loop bounds, so we iterate over L (the array size)\n // instead of word_count (runtime value). The condition `i < word_count` ensures we only\n // process valid encoded words. This is safe because word_count <= L always holds\n // (we can have at most L encoded words from L input operations).\n for i in 0..L {\n if i < word_count {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append full 64-byte domain separator.\n for i in 0..64 {\n input_bytes[byte_count] = domain_separator[i];\n byte_count += 1;\n }\n\n // Step 3: Hash with Keccak-256 and truncate to 128 bits.\n // Note: The SAFE spec uses SHA3-256, but we use Keccak-256 for Noir compatibility.\n // Keccak-256 differs from SHA3-256 in padding, but both provide equivalent security.\n let hash_bytes = keccak256(input_bytes, byte_count);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = [123].as_vector();\n let right = [456].as_vector();\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = [10, 20, 30].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = [1, 2, 3].as_vector();\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1[0] != output2[0]); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output[0] != 0);\n assert(output[1] != 0);\n assert(output[0] != output[1]); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb([].as_vector());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println("=== SAFE Tag Computation Debug Test ===");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f"Testing pattern: {io_pattern}");\n println(\n f"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)",\n );\n println(\n f"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]",\n );\n println("");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f"=== Expected Rust Output ===");\n println("Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))");\n println("Domain separator: 0x41424344...");\n println("Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a");\n println("");\n\n println(f"=== Noir Output ===");\n println(f"Tag: {tag}");\n println("");\n\n println("Compare the tag values above with Rust script!");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Consecutive ABSORB operations should aggregate to the same tag");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive ABSORB operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive ABSORB Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n "Consecutive SQUEEZE operations should aggregate to the same tag",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive SQUEEZE operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive SQUEEZE Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Mixed consecutive operations should aggregate to the same tag");\n\n println("=== Mixed Consecutive Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]",\n );\n println(\n f" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))",\n );\n println(f"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]");\n println(f" (ABSORB(2), SQUEEZE(2), ABSORB(1))");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n}\n\n#[test]\nfn test_large_io_pattern() {\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Create pattern with 48 alternating ABSORB(1) and SQUEEZE(1) operations\n // This is the maximum supported (48 words * 4 bytes = 192 bytes, leaving 64 for domain separator)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1; // ABSORB(1)\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1; // SQUEEZE(1)\n }\n }\n\n let tag = compute_tag(io_pattern, domain_separator);\n assert(tag != 0);\n}\n\n#[test]\nfn test_domain_separator_not_truncated() {\n // This test verifies that the domain separator is always included in the tag computation,\n // even for large IO patterns. If the domain separator were truncated, different domain\n // separators would produce the same tag for large patterns.\n\n let domain_separator_a = [\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41,\n ]; // All \'A\'s\n\n let domain_separator_b = [\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42,\n ]; // All \'B\'s\n\n // Create pattern with 48 alternating operations (max supported: 192 bytes of IO pattern)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1;\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1;\n }\n }\n\n let tag_a = compute_tag(io_pattern, domain_separator_a);\n let tag_b = compute_tag(io_pattern, domain_separator_b);\n\n // Tags MUST be different because domain separators are different.\n // If they were the same, it would mean the domain separator was truncated/ignored.\n assert(tag_a != tag_b, "Domain separator must affect tag even for large IO patterns");\n}\n', path: "/Users/ctrlc03/.omp/worktrees/interfold/feat-insecure-64-params/circuits/lib/src/math/safe.nr", function_locations: [{ start: 4164, name: "SafeSponge<L>::start" }, { start: 5046, name: "SafeSponge<L>::absorb" }, { start: 6826, name: "SafeSponge<L>::squeeze" }, { start: 8494, name: "SafeSponge<L>::finish" }, { start: 9156, name: "SafeSponge<L>::permute" }, { start: 9830, name: "compute_tag" }, { start: 14128, name: "test_safe_hashing" }, { start: 15104, name: "test_merkle_node" }, { start: 16281, name: "test_commitment_scheme" }, { start: 17357, name: "test_domain_separation" }, { start: 18710, name: "test_multiple_squeeze" }, { start: 19639, name: "test_zero_length_operations" }, { start: 20415, name: "test_tag_computation" }, { start: 21477, name: "test_tag_computation_debug" }, { start: 22681, name: "test_consecutive_absorb_aggregation" }, { start: 24750, name: "test_consecutive_squeeze_aggregation" }, { start: 26760, name: "test_mixed_consecutive_aggregation" }, { start: 28520, name: "test_large_io_pattern" }, { start: 29333, name: "test_domain_separator_not_truncated" }] }, "171": { source: "mod tests;\nmod oracle_tests;\nmod benchmarks;\n\nuse std::hash::keccakf1600;\nuse std::runtime::is_unconstrained;\n\nglobal BLOCK_SIZE_IN_BYTES: u32 = 136; //(1600 - BITS * 2) / WORD_SIZE;\nglobal WORD_SIZE: u32 = 8; // Limbs are made up of u64s so 8 bytes each.\nglobal LIMBS_PER_BLOCK: u32 = BLOCK_SIZE_IN_BYTES / WORD_SIZE;\nglobal NUM_KECCAK_LANES: u32 = 25;\n\n#[no_predicates]\npub fn keccak256<let N: u32>(input: [u8; N], message_size: u32) -> [u8; 32] {\n assert(N >= message_size);\n\n // Copy input to block bytes. For that we'll need at least input bytes (N)\n // but we want it to be padded to a multiple of BLOCK_SIZE_IN_BYTES.\n let mut block_bytes = [0; ((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES];\n if is_unconstrained() {\n for i in 0..message_size {\n block_bytes[i] = input[i];\n }\n } else {\n for i in 0..N {\n if i < message_size {\n block_bytes[i] = input[i];\n }\n }\n }\n\n //1. format_input_lanes and apply padding\n let max_blocks = (N + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;\n let real_max_blocks = (message_size + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES;\n\n // Apply Keccak padding (0x01 after message, 0x80 at block end)\n apply_keccak_padding(&mut block_bytes, message_size, real_max_blocks);\n\n // populate a vector of 64-bit limbs from our byte array\n let mut sliced_buffer =\n [0; (((N / BLOCK_SIZE_IN_BYTES) + 1) * BLOCK_SIZE_IN_BYTES) / WORD_SIZE];\n for i in 0..sliced_buffer.len() {\n let limb_start = WORD_SIZE * i;\n\n let mut sliced = 0;\n let mut v = 1;\n for k in 0..WORD_SIZE {\n sliced += v * (block_bytes[limb_start + k] as Field);\n v *= 256;\n }\n\n sliced_buffer[i] = sliced as u64;\n }\n\n //2. sponge_absorb\n let mut state: [u64; NUM_KECCAK_LANES] = [0; NUM_KECCAK_LANES];\n // `real_max_blocks` is guaranteed to at least be `1`\n // We peel out the first block as to avoid a conditional inside of the loop.\n // Otherwise, a dynamic predicate can cause a blowup in a constrained runtime.\n for j in 0..LIMBS_PER_BLOCK {\n state[j] = sliced_buffer[j];\n }\n state = keccakf1600(state);\n\n let state = if is_unconstrained() {\n // When in an unconstrained runtime we can take advantage of runtime loop bounds,\n // thus allowing us to simplify the loop body.\n for i in 1..real_max_blocks {\n for j in 0..LIMBS_PER_BLOCK {\n state[j] = state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];\n }\n state = keccakf1600(state);\n }\n\n state\n } else {\n // We store the intermediate states in an array to avoid having a dynamic predicate\n // inside the loop, which can cause a blowup in a constrained runtime.\n let mut intermediate_states = [state; (N + BLOCK_SIZE_IN_BYTES) / BLOCK_SIZE_IN_BYTES + 1];\n for i in 1..max_blocks {\n let mut previous_state = intermediate_states[i - 1];\n for j in 0..LIMBS_PER_BLOCK {\n previous_state[j] = previous_state[j] ^ sliced_buffer[i * LIMBS_PER_BLOCK + j];\n }\n intermediate_states[i] = keccakf1600(previous_state);\n }\n\n // We can then take the state as of `real_max_blocks`, ignoring later permutations.\n intermediate_states[real_max_blocks - 1]\n };\n\n //3. sponge_squeeze\n let mut result = [0; 32];\n for i in 0..4 {\n let lane = state[i] as Field;\n let lane_le: [u8; 8] = lane.to_le_bytes();\n for j in 0..8 {\n result[8 * i + j] = lane_le[j];\n }\n }\n result\n}\n\n// Apply Keccak padding to the block_bytes array\n// Append 0x01 after message, then 0x80 at end of block\n// If both padding bytes collide at the same byte, combine them as 0x81\npub(crate) fn apply_keccak_padding<let BLOCK_BYTES: u32>(\n block_bytes: &mut [u8; BLOCK_BYTES],\n message_size: u32,\n real_max_blocks: u32,\n) {\n let real_blocks_bytes = real_max_blocks * BLOCK_SIZE_IN_BYTES;\n\n block_bytes[message_size] = 0x01;\n\n if message_size == real_blocks_bytes - 1 {\n // Combine both padding bits: 0x01 | 0x80 = 0x81\n block_bytes[message_size] = 0x81;\n } else {\n block_bytes[real_blocks_bytes - 1] = 0x80;\n }\n}\n", path: "/Users/ctrlc03/nargo/github.com/noir-lang/keccak256/v0.1.2/src/keccak256.nr", function_locations: [{ start: 448, name: "keccak256" }, { start: 3998, name: "apply_keccak_padding" }] } } };
6
+
7
+ // ../../circuits/dist/insecure-64/user_data_encryption_ct0.json
8
+ var user_data_encryption_ct0_default = { noir_version: "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905", hash: "1857863687514063383", abi: { parameters: [{ name: "pk0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct0is", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "u", type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "e0", type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "k1", type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "r", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }], return_type: { abi_type: { kind: "tuple", fields: [{ kind: "field" }, { kind: "field" }, { kind: "field" }, { kind: "field" }] }, visibility: "public" }, error_types: { "12469291177396340830": { error_kind: "string", string: "call to assert_max_bit_size" }, "15579388420377730771": { error_kind: "string", string: "ct0 encryption check failed" } } }, bytecode: "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", debug_symbols: "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", file_map: { "16": { 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', path: "std/field/mod.nr", function_locations: [{ start: 380, name: "Field::assert_max_bit_size" }, { start: 1196, name: "Field::to_le_bits" }, { start: 2387, name: "Field::to_be_bits" }, { start: 3562, name: "Field::to_le_bytes" }, { start: 5033, name: "Field::to_be_bytes" }, { start: 5904, name: "Field::to_le_radix" }, { start: 6362, name: "Field::to_be_radix" }, { start: 7053, name: "Field::pow_32" }, { start: 7455, name: "Field::sgn0" }, { start: 7538, name: "Field::lt" }, { start: 8073, name: "Field::from_le_bytes" }, { start: 8820, name: "Field::from_be_bytes" }, { start: 9611, name: "Field::from_le_bytes_checked" }, { start: 10620, name: "Field::from_be_bytes_checked" }, { start: 11202, name: "__assert_max_bit_size" }, { start: 11330, name: "__to_le_radix" }, { start: 11458, name: "__to_be_radix" }, { start: 12179, name: "__to_le_bits" }, { start: 12897, name: "__to_be_bits" }, { start: 12972, name: "modulus_num_bits" }, { start: 13048, name: "modulus_be_bits" }, { start: 13124, name: "modulus_le_bits" }, { start: 13200, name: "modulus_be_bytes" }, { start: 13276, name: "modulus_le_bytes" }, { start: 13437, name: "__field_less_than" }, { start: 13513, name: "field_less_than" }, { start: 13589, name: "lt_fallback" }, { start: 14551, name: "tests::test_to_be_bits" }, { start: 14824, name: "tests::test_to_le_bits" }, { start: 15099, name: "tests::test_to_be_bytes" }, { start: 15405, name: "tests::test_to_le_bytes" }, { start: 15711, name: "tests::test_to_be_radix" }, { start: 16293, name: "tests::test_to_le_radix" }, { start: 16893, name: "tests::test_to_le_radix_1" }, { start: 17346, name: "tests::test_to_le_radix_brillig_1" }, { start: 17700, name: "tests::test_to_le_radix_3" }, { start: 18011, name: "tests::test_to_le_radix_brillig_3" }, { start: 18439, name: "tests::test_to_le_radix_512" }, { start: 18848, name: "tests::not_enough_limbs_brillig" }, { start: 19044, name: "tests::not_enough_limbs" }, { start: 19274, name: "tests::non_zero_field_to_le_bytes_zero_limbs" }, { start: 19469, name: "tests::non_zero_field_to_be_bytes_zero_limbs" }, { start: 19600, name: "tests::zero_field_to_bytes_zero_limbs_unconstrained" }, { start: 19915, name: "tests::zero_field_to_bytes_zero_limbs_constrained" }, { start: 20227, name: "tests::zero_field_to_bytes_zero_limbs_comptime" }, { start: 20558, name: "tests::test_field_less_than" }, { start: 20813, name: "tests::test_large_field_values_unconstrained" }, { start: 21266, name: "tests::test_large_field_values" }, { start: 21713, name: "tests::test_decomposition_edge_cases" }, { start: 22303, name: "tests::test_pow_32" }, { start: 22632, name: "tests::test_sgn0" }, { start: 23054, name: "tests::test_bit_decomposition_overflow" }, { start: 23336, name: "tests::test_byte_decomposition_overflow" }, { start: 23553, name: "tests::test_to_from_be_bytes_bn254_edge_cases" }, { start: 25504, name: "tests::test_to_from_le_bytes_bn254_edge_cases" }, { start: 27439, name: "tests::test_from_le_bytes_checked_accepts_modulus_minus_one" }, { start: 27918, name: "tests::test_from_le_bytes_checked_rejects_modulus" }, { start: 28303, name: "tests::test_from_le_bytes_checked_rejects_modulus_plus_one" }, { start: 28758, name: "tests::test_from_be_bytes_checked_accepts_modulus_minus_one" }, { start: 29247, name: "tests::test_from_be_bytes_checked_rejects_modulus" }, { start: 29632, name: "tests::test_from_be_bytes_checked_rejects_modulus_plus_one" }, { start: 30076, name: "tests::test_from_bytes_checked_small_n" }, { start: 30721, name: "tests::from_le_bits" }, { start: 31268, name: "tests::from_be_bits" }, { start: 31514, name: "tests::test_to_from_be_bits_bn254_edge_cases" }, { start: 33447, name: "tests::test_to_from_le_bits_bn254_edge_cases" }, { start: 35379, name: "tests::max_bit_size_too_large" }] }, "17": { 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', path: "std/hash/mod.nr", function_locations: [{ start: 572, name: "sha256_compression" }, { start: 707, name: "keccakf1600" }, { start: 852, name: "blake2s" }, { start: 950, name: "blake3" }, { start: 1437, name: "__blake3" }, { start: 1555, name: "pedersen_commitment" }, { start: 1784, name: "pedersen_commitment_with_separator" }, { start: 2188, name: "pedersen_hash" }, { start: 2345, name: "pedersen_hash_with_separator" }, { start: 3339, name: "derive_generators" }, { start: 3698, name: "__derive_generators" }, { start: 3776, name: "poseidon2_permutation" }, { start: 4132, name: "poseidon2_permutation_internal" }, { start: 4225, name: "poseidon2_config_state_size" }, { start: 4536, name: "derive_hash" }, { start: 5327, name: "Hasher::finish_ref" }, { start: 5761, name: "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher" }, { start: 5893, name: "<impl Default for BuildHasherDefault<H>>::default" }, { start: 6025, name: "<impl Hash for Field>::hash" }, { start: 6155, name: "<impl Hash for u8>::hash" }, { start: 6295, name: "<impl Hash for u16>::hash" }, { start: 6435, name: "<impl Hash for u32>::hash" }, { start: 6575, name: "<impl Hash for u64>::hash" }, { start: 6716, name: "<impl Hash for u128>::hash" }, { start: 6855, name: "<impl Hash for i8>::hash" }, { start: 7001, name: "<impl Hash for i16>::hash" }, { start: 7148, name: "<impl Hash for i32>::hash" }, { start: 7295, name: "<impl Hash for i64>::hash" }, { start: 7443, name: "<impl Hash for bool>::hash" }, { start: 7590, name: "<impl Hash for ()>::hash" }, { start: 7722, name: "<impl Hash for [T; N]>::hash" }, { start: 7911, name: "<impl Hash for [T]>::hash" }, { start: 8133, name: "<impl Hash for (A,)>::hash" }, { start: 8302, name: "<impl Hash for (A, B)>::hash" }, { start: 8518, name: "<impl Hash for (A, B, C)>::hash" }, { start: 8781, name: "<impl Hash for (A, B, C, D)>::hash" }, { start: 9091, name: "<impl Hash for (A, B, C, D, E)>::hash" }, { start: 9448, name: "<impl Hash for (A, B, C, D, E, F)>::hash" }, { start: 9852, name: "<impl Hash for (A, B, C, D, E, F, G)>::hash" }, { start: 10306, name: "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash" }, { start: 10807, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash" }, { start: 11355, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash" }, { start: 11950, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash" }, { start: 12593, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash" }, { start: 13187, name: "assert_pedersen" }] }, "52": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse lib::configs::default::threshold::{\n L, N, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_E0, USER_DATA_ENCRYPTION_BIT_K,\n USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CT0_BIT_R,\n USER_DATA_ENCRYPTION_CT0_CONFIGS,\n};\nuse lib::core::threshold::user_data_encryption_ct0::UserDataEncryptionCt0;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n pk0is: [Polynomial<N>; L],\n ct0is: [Polynomial<N>; L],\n u: Polynomial<N>,\n e0: Polynomial<N>,\n k1: Polynomial<N>,\n r: [Polynomial<N>; L],\n) -> pub (Field, Field, Field, Field) {\n let circuit: UserDataEncryptionCt0<N, L, USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_BIT_E0, USER_DATA_ENCRYPTION_BIT_K, USER_DATA_ENCRYPTION_CT0_BIT_R> =\n UserDataEncryptionCt0::new(USER_DATA_ENCRYPTION_CT0_CONFIGS, pk0is, ct0is, u, e0, k1, r);\n\n circuit.execute()\n}\n", path: "interfold/circuits/bin/threshold/user_data_encryption_ct0/src/main.nr", function_locations: [{ start: 778, name: "main" }] }, "83": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! User-data encryption - ct0 leg (P3).\n//!\n//! See `UserDataEncryptionCt0` for the circuit contract.\n\nuse crate::math::commitments::compute_multiple_polynomial_commitment;\nuse crate::math::commitments::compute_single_polynomial_commitment;\nuse crate::math::commitments::compute_user_data_encryption_ct0_challenge;\nuse crate::math::commitments::DS_CIPHERTEXT;\nuse crate::math::commitments::DS_PK_AGGREGATION;\nuse crate::math::commitments::DS_USER_DATA_ENCRYPTION_COMMITMENT;\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::{negacyclic_kernel, Polynomial};\n\n/// Parameters for user-data encryption ct0 (P3).\npub struct Configs<let N: u32, let L: u32> {\n pub qis: [Field; L],\n pub k0is: [Field; L],\n /// Bound for the lifted error polynomial (e0) coefficients\n pub e0_bound: Field,\n pub u_bound: Field,\n /// Bounds on `r`, the quotient of the mod-`q` reduction.\n pub r_bounds: [Field; L],\n pub k1_low_bound: Field,\n pub k1_up_bound: Field,\n}\n\nimpl<let N: u32, let L: u32> Configs<N, L> {\n pub fn new(\n qis: [Field; L],\n k0is: [Field; L],\n e0_bound: Field,\n u_bound: Field,\n r_bounds: [Field; L],\n k1_low_bound: Field,\n k1_up_bound: Field,\n ) -> Self {\n Configs { qis, k0is, e0_bound, u_bound, r_bounds, k1_low_bound, k1_up_bound }\n }\n}\n\n/// User-data encryption ct0 (P3).\n///\n/// **Role:** Prove the first ciphertext leg and publish `pk0`, `ct0`, `k1`, and `u` commitments\n/// for the wrapper and ct1 circuit.\n///\n/// **Consumes:** Threshold PK from C5 (`pk0is` witness path).\n///\n/// **Produces:** `(pk0_commitment, ct0_commitment, k1_commitment, u_commitment)` public outputs.\npub struct UserDataEncryptionCt0<let N: u32, let L: u32, let BIT_PK: u32, let BIT_CT: u32, let BIT_U: u32, let BIT_E0: u32, let BIT_K: u32, let BIT_R: u32> {\n configs: Configs<N, L>,\n /// Aggregated threshold `pk0` limb (from C5).\n pk0is: [Polynomial<N>; L],\n ct0is: [Polynomial<N>; L],\n u: Polynomial<N>,\n e0: Polynomial<N>,\n k1: Polynomial<N>,\n /// Quotient of the mod-`q` reduction, already reduced modulo `X^N + 1` by the prover. It absorbs\n /// what `e0is`, `r1is` and `r2is` carried between them: substituting the CRT split removes `e0is`,\n /// and `X^N = -1` makes the cyclotomic quotient\'s term identically zero.\n r: [Polynomial<N>; L],\n}\n\nimpl<let N: u32, let L: u32, let BIT_PK: u32, let BIT_CT: u32, let BIT_U: u32, let BIT_E0: u32, let BIT_K: u32, let BIT_R: u32> UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R> {\n\n pub fn new(\n configs: Configs<N, L>,\n pk0is: [Polynomial<N>; L],\n ct0is: [Polynomial<N>; L],\n u: Polynomial<N>,\n e0: Polynomial<N>,\n k1: Polynomial<N>,\n r: [Polynomial<N>; L],\n ) -> Self {\n UserDataEncryptionCt0 { configs, pk0is, ct0is, u, e0, k1, r }\n }\n\n /// Bounds every value the reduced identity is checked over.\n ///\n /// The identity is verified at one random point, so each coefficient needs a bound for the field\n /// equality to imply the integer one. `pk0is` / `ct0is` are centered residues mod `q_i`, and `r`\n /// is the prover-supplied reduction quotient.\n fn check_range_bounds(self) {\n self.u.range_check_2bounds::<BIT_U>(self.configs.u_bound, self.configs.u_bound);\n self.e0.range_check_2bounds::<BIT_E0>(self.configs.e0_bound, self.configs.e0_bound);\n self.k1.range_check_2bounds::<BIT_K>(self.configs.k1_up_bound, self.configs.k1_low_bound);\n\n for i in 0..L {\n let half = (self.configs.qis[i] - 1) / 2;\n self.pk0is[i].range_check_2bounds::<BIT_PK>(half, half);\n self.ct0is[i].range_check_2bounds::<BIT_CT>(half, half);\n self.r[i].range_check_2bounds::<BIT_R>(\n self.configs.r_bounds[i],\n self.configs.r_bounds[i],\n );\n }\n }\n\n fn generate_commitments(self) -> (Field, Field, Field, Field) {\n // `check_range_bounds` bounds all four vectors, so the plain packing is already injective and\n // the digit asserts would be redundant.\n let pk0_commitment =\n compute_multiple_polynomial_commitment::<N, L, BIT_PK>(self.pk0is, DS_PK_AGGREGATION);\n let ct0_commitment =\n compute_multiple_polynomial_commitment::<N, L, BIT_CT>(self.ct0is, DS_CIPHERTEXT);\n let k1_commitment = compute_single_polynomial_commitment::<N, BIT_K>(\n self.k1,\n DS_USER_DATA_ENCRYPTION_COMMITMENT,\n );\n let u_commitment = compute_single_polynomial_commitment::<N, BIT_U>(\n self.u,\n DS_USER_DATA_ENCRYPTION_COMMITMENT,\n );\n\n (pk0_commitment, ct0_commitment, k1_commitment, u_commitment)\n }\n\n fn generate_challenge(\n self,\n pk0_commitment: Field,\n ct0_commitment: Field,\n k1_commitment: Field,\n u_commitment: Field,\n ) -> [Field] {\n let mut payload = [pk0_commitment, ct0_commitment, k1_commitment, u_commitment].as_vector();\n\n payload = flatten::<_, _, BIT_E0>(payload, [self.e0]);\n // `r` replaces `e0is`, `r1is` and `r2is` in the transcript, and it is bounded, so the plain\n // packing stays injective.\n payload = flatten::<_, _, BIT_R>(payload, self.r);\n\n compute_user_data_encryption_ct0_challenge::<L>(payload)\n }\n\n /// Checks `ct0is = pk0is * u + e0 + k0is * k1 + q_i * r` modulo `X^N + 1`, at one point.\n ///\n /// `negacyclic_kernel` supplies the reduced product `pk0is * u mod X^N + 1` evaluated at `x`, so\n /// the product never enters the witness and the cyclotomic quotient is gone with it.\n fn verify_evaluations(self, gammas: [Field]) -> bool {\n let x = gammas[0];\n let k = negacyclic_kernel(self.u, x);\n\n let mut holds = true;\n for i in 0..L {\n let mut residual = [0; N];\n for j in 0..N {\n residual[j] = self.ct0is[i].coefficients[j]\n - self.e0.coefficients[j]\n - self.configs.k0is[i] * self.k1.coefficients[j]\n - self.configs.qis[i] * self.r[i].coefficients[j];\n }\n holds = holds & (Polynomial::new(residual).eval(x) == self.pk0is[i].dot(k));\n }\n\n holds\n }\n\n /// Returns `(pk0_commitment, ct0_commitment, k1_commitment, u_commitment)`.\n pub fn execute(self) -> (Field, Field, Field, Field) {\n // Step 1: bound everything the reduced identity is read over.\n self.check_range_bounds();\n\n // Step 2: Domain-separated commitments for the FS transcript.\n let (pk0_commitment, ct0_commitment, k1_commitment, u_commitment) =\n self.generate_commitments();\n\n // Step 3: Fiat-Shamir challenge and evaluation check of the reduced ct0 equation.\n let gammas =\n self.generate_challenge(pk0_commitment, ct0_commitment, k1_commitment, u_commitment);\n\n assert(self.verify_evaluations(gammas), "ct0 encryption check failed");\n\n (pk0_commitment, ct0_commitment, k1_commitment, u_commitment)\n }\n}\n\n/// An honest witness satisfies the reduced ct0 identity, with a nonzero `r`.\n///\n/// Worked by hand at `N = 4`, `q = 97`, `k0 = 5`: `pk0 * u mod X^4 + 1` is `[-50, -30, -10, -50]`,\n/// and adding `e0 = [0, 0, 0, 1]` and `k0 * k1 = 5 * [0, 0, 1, 0]` gives `[-50, -30, -5, -49]`. Two\n/// coefficients fall below `-(q-1)/2`, so the centered ciphertext is `[47, -30, -5, 48]` and the\n/// reduction quotient is `r = [1, 0, 0, 1]`.\n#[test]\nfn honest_reduced_identity_holds() {\n let pk0 = Polynomial::new([30, 40, -20, 10]);\n let u = Polynomial::new([0, 1, 0, -1]);\n let e0 = Polynomial::new([0, 0, 0, 1]);\n let k1 = Polynomial::new([0, 0, 1, 0]);\n let ct0 = Polynomial::new([47, -30, -5, 48]);\n let r = Polynomial::new([1, 0, 0, 1]);\n\n // qis, k0is, e0_bound, u_bound, r_bounds, k1_low_bound, k1_up_bound\n let configs: Configs<4, 1> = Configs::new([97], [5], 1, 1, [3], 1, 1);\n let c: UserDataEncryptionCt0<4, 1, 6, 6, 1, 1, 1, 3> =\n UserDataEncryptionCt0::new(configs, [pk0], [ct0], u, e0, k1, [r]);\n let _ = c.execute();\n}\n', path: "interfold/circuits/lib/src/core/threshold/user_data_encryption_ct0.nr", function_locations: [{ start: 1436, name: "Configs<N, L>::new" }, { start: 3003, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::new" }, { start: 3442, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::check_range_bounds" }, { start: 4176, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::generate_commitments" }, { start: 5153, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::generate_challenge" }, { start: 5940, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::verify_evaluations" }, { start: 6656, name: "UserDataEncryptionCt0<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E0, BIT_K, BIT_R>::execute" }, { start: 7795, name: "honest_reduced_identity_holds" }] }, "86": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::helpers::{compute_safe, flatten, flatten_checked};\nuse crate::math::polynomial::Polynomial;\n\n/// DOMAIN SEPARATORS\n\n// Domain separator - "PK"\npub global DS_PK: [u8; 64] = [\n 0x50, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_GENERATION"\npub global DS_PK_GENERATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_COMPUTATION"\npub global DS_SHARE_COMPUTATION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_ENCRYPTION"\npub global DS_SHARE_ENCRYPTION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_AGGREGATION"\npub global DS_PK_AGGREGATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CIPHERTEXT"\npub global DS_CIPHERTEXT: [u8; 64] = [\n 0x43, 0x49, 0x50, 0x48, 0x45, 0x52, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "AGGREGATED_SHARES"\npub global DS_AGGREGATED_SHARES: [u8; 64] = [\n 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45,\n 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "VK_HASH"\npub global DS_VK_HASH: [u8; 64] = [\n 0x56, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "RECURSIVE_AGGREGATION"\npub global DS_RECURSIVE_AGGREGATION: [u8; 64] = [\n 0x52, 0x45, 0x43, 0x55, 0x52, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47,\n 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_PK_GENERATION"\npub global DS_CLG_PK_GENERATION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_ENCRYPTION"\npub global DS_CLG_SHARE_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_USER_DATA_ENCRYPTION"\npub global DS_CLG_USER_DATA_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e,\n 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_DECRYPTION"\npub global DS_CLG_SHARE_DECRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "THRESHOLD_DECRYPTION_SHARE"\npub global DS_THRESHOLD_DECRYPTION_SHARE: [u8; 64] = [\n 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "USER_DATA_ENCRYPTION_COMMITMENT"\npub global DS_USER_DATA_ENCRYPTION_COMMITMENT: [u8; 64] = [\n 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n/// WRAPPERS\n\npub fn compute_commitment(inputs: [Field], domain_separator: [u8; 64]) -> Field {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 1])[0]\n}\n\npub fn compute_single_polynomial_commitment<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_single_polynomial_commitment`] with the digit asserts, for a polynomial this circuit\n/// carries no bound for. ct1 commits `u` this way: ct0 range-checks the same `u` to `u_bound` and the\n/// `user_data_encryption` fold asserts the two `u` commitments are equal, so making ct1\'s packing\n/// injective is what forces its `u` to equal ct0\'s \u2014 the bound transfers instead of being repeated.\n/// Produces the same value as the plain version for any input the plain version could legitimately\n/// have committed.\npub fn compute_single_polynomial_commitment_checked<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_multiple_polynomial_commitment<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_challenge<let L: u32>(inputs: [Field], domain_separator: [u8; 64]) -> [Field] {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 2 * L])\n}\n\npub fn single_polynomial_payload<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\npub fn single_polynomial_payload_checked<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload_checked<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n payload = multiple_polynomial_payload::<N, L, BIT_PK>(payload, pk1);\n\n compute_commitment(payload, DS_PK)\n}\n\npub fn compute_threshold_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\n/// [`compute_multiple_polynomial_commitment`] for a circuit that **opens** this commitment.\npub fn compute_multiple_polynomial_commitment_checked<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_threshold_pk_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C5). Asserts each packed digit fits its slot, which makes the opening unique and so\n/// forces the opened `pk0` to equal the `pk0` C1 committed. Produces the same value as the plain\n/// helper, so C1 needs no change.\npub fn compute_threshold_pk_commitment_checked<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\npub fn compute_share_computation_sk_commitment<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\n/// [`compute_share_computation_sk_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2a). C1 creates it and bounds `sk` to the trinary range, so making the opening\n/// unique forces the witness to equal that `sk`.\npub fn compute_share_computation_sk_commitment_checked<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_computation_e_sm_commitment<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_encryption_commitment_from_message<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\n/// [`compute_share_encryption_commitment_from_message`] for a circuit that **opens** this\n/// commitment rather than creating it (C4). Asserts each packed digit fits its slot, forcing the\n/// opened share to equal the share C2 committed. Same value as the plain helper, so C2 and C3 need\n/// no change.\npub fn compute_share_encryption_commitment_from_message_checked<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\npub fn compute_aggregated_shares_commitment<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// Commitment to a threshold decryption share: all CRT limbs, first `K` coefficients per limb\n/// (same layout as `Polynomial<K>` in decrypted_shares_aggregation).\n///\n/// `NATIVE_BIT_WIDTH` must cover native coefficients in \\([0, q_l)\\) per limb (not centered `d` bounds).\npub fn compute_threshold_decryption_share_commitment<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload =\n multiple_polynomial_payload::<K, L, NATIVE_BIT_WIDTH>([].as_vector(), d_share_limbs);\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_threshold_decryption_share_commitment`] for a circuit that **opens** this commitment\n/// rather than creating it (C7). C6 creates it and pins each coefficient to a native residue in\n/// \\([0, q)\\) via `verify_d_native_trunc_binding`, so asserting the digits here makes the opening\n/// unique and forces the opened share to equal the one C6 committed. Produces the same value as the\n/// plain version for any input the plain version could legitimately have committed.\npub fn compute_threshold_decryption_share_commitment_checked<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<K, L, NATIVE_BIT_WIDTH>(\n [].as_vector(),\n d_share_limbs,\n );\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_share_computation_e_sm_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2b). C1 creates it and bounds each `e_sm` limb to a centered residue.\npub fn compute_share_computation_e_sm_commitment_checked<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_pk_aggregation_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let commit_pk0 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk0, DS_PK_AGGREGATION);\n let commit_pk1 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk1, DS_PK_AGGREGATION);\n\n let inputs = [commit_pk0, commit_pk1].as_vector();\n\n compute_commitment(inputs, DS_PK_AGGREGATION)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: [Field]) -> Field {\n compute_commitment(payload, DS_RECURSIVE_AGGREGATION)\n}\n\npub fn compute_vk_hash(vk_hashes: [Field]) -> Field {\n compute_commitment(vk_hashes, DS_VK_HASH)\n}\n\n/// [`compute_aggregated_shares_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). C4 creates it after `normalize_aggregated` has reduced and centered the\n/// aggregate, so making the opening unique forces the witness to equal that canonical value.\npub fn compute_aggregated_shares_commitment_checked<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// [`compute_ciphertext_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). No upstream circuit bounds the ciphertext limbs, so this buys injectivity\n/// rather than canonicality \u2014 which is the property wanted here: it forces C6 to decrypt exactly\n/// the ciphertext that was committed, whatever its representation.\npub fn compute_ciphertext_commitment_checked<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\npub fn compute_ciphertext_commitment<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: [Field]) -> Field {\n compute_commitment(payload, DS_CLG_PK_GENERATION)\n}\n\npub fn compute_share_encryption_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_SHARE_ENCRYPTION)\n}\n\npub fn compute_threshold_share_decryption_challenge<let L: u32>(payload: [Field]) -> Field {\n compute_challenge::<L>(payload, DS_CLG_SHARE_DECRYPTION)[0]\n}\n\npub fn compute_user_data_encryption_ct0_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n\npub fn compute_user_data_encryption_ct1_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n', path: "interfold/circuits/lib/src/math/commitments.nr", function_locations: [{ start: 7784, name: "compute_commitment" }, { start: 8012, name: "compute_single_polynomial_commitment" }, { start: 8827, name: "compute_single_polynomial_commitment_checked" }, { start: 9138, name: "compute_multiple_polynomial_commitment" }, { start: 9375, name: "compute_challenge" }, { start: 9585, name: "single_polynomial_payload" }, { start: 9784, name: "multiple_polynomial_payload" }, { start: 9970, name: "single_polynomial_payload_checked" }, { start: 10185, name: "multiple_polynomial_payload_checked" }, { start: 10406, name: "compute_dkg_pk_commitment" }, { start: 10733, name: "compute_threshold_pk_commitment" }, { start: 11138, name: "compute_multiple_polynomial_commitment_checked" }, { start: 11750, name: "compute_threshold_pk_commitment_checked" }, { start: 12008, name: "compute_share_computation_sk_commitment" }, { start: 12516, name: "compute_share_computation_sk_commitment_checked" }, { start: 12795, name: "compute_share_computation_e_sm_commitment" }, { start: 13067, name: "compute_share_encryption_commitment_from_message" }, { start: 13647, name: "compute_share_encryption_commitment_from_message_checked" }, { start: 13931, name: "compute_aggregated_shares_commitment" }, { start: 14512, name: "compute_threshold_decryption_share_commitment" }, { start: 15336, name: "compute_threshold_decryption_share_commitment_checked" }, { start: 15876, name: "compute_share_computation_e_sm_commitment_checked" }, { start: 16182, name: "compute_pk_aggregation_commitment" }, { start: 16571, name: "compute_recursive_aggregation_commitment" }, { start: 16686, name: "compute_vk_hash" }, { start: 17169, name: "compute_aggregated_shares_commitment_checked" }, { start: 17843, name: "compute_ciphertext_commitment_checked" }, { start: 18325, name: "compute_ciphertext_commitment" }, { start: 18724, name: "compute_threshold_pk_challenge" }, { start: 18866, name: "compute_share_encryption_challenge" }, { start: 19023, name: "compute_threshold_share_decryption_challenge" }, { start: 19183, name: "compute_user_data_encryption_ct0_challenge" }, { start: 19344, name: "compute_user_data_encryption_ct1_challenge" }] }, "88": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Helper functions for circuit construction and cryptographic operations.\nuse crate::math::polynomial::Polynomial;\nuse crate::math::safe::SafeSponge;\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by pack/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout<let BIT: u32>() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n // `group == 1` packs one value per carrier: it saves no sponge absorptions at all while still\n // charging the range checks that make packing injective, so it is always a loss. Measured at\n // BIT=143: +82% gates against absorbing directly. Reject it rather than pay for nothing.\n assert(group >= 2);\n (nibble_bits, group)\n}\n\n/// Like [`pack`], but asserts every digit fits its slot.\n///\n/// ## Why\n/// `pack` builds each carrier as a base-`radix` number, `acc = acc * radix + (v + base)`. That\n/// representation is unique only while every digit stays below `radix`. An unbounded value can\n/// overflow its slot and cancel against the next, so one commitment gains a second opening and a\n/// prover can choose which coefficients it opens to.\n///\n/// `digit < radix` is exactly `digit.assert_max_bit_size::<nibble_bits + 4>()`, and because\n/// `assert_max_bit_size` also forces `digit >= 0`, a single assert gives the whole condition.\n///\n/// ## When to use it\n/// Use this where a circuit **opens** a commitment it did not create. The creating circuit's own\n/// range checks already keep its digits in slot, so asserting the same here forces the opened\n/// coefficients to equal the committed ones \u2014 injectivity transfers the upstream bound without\n/// repeating it. One assert costs about half a two-sided `range_check_2bounds`.\n///\n/// It does **not** replace a bound the protocol requires in its own right, and it gives injectivity,\n/// not canonicality: it pins the opening, not a unique representative modulo `q`. A value that no\n/// upstream circuit bounded still needs its own check (see C1 `pk0` and C5 `pk0_agg`).\n///\n/// ## Compatibility\n/// Adding asserts does not change the packed value, so a commitment created with [`pack`] and\n/// opened with `pack_checked` agree. Adoption is per circuit and needs no commitment change.\npub fn pack_checked<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field);\n let radix = 2.pow_32((nibble_bits + 4) as Field);\n\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n for chunk in 0..num_chunks {\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n let digit = v + base;\n // digit < radix = 2^(nibble_bits + 4): the injectivity condition.\n digit.assert_max_bit_size::<((BIT + 3) / 4) * 4 + 4>();\n acc = acc * radix + digit;\n }\n\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Like [`flatten`], but packs with [`pack_checked`]. Use where a circuit opens a commitment it did\n/// not create.\npub fn flatten_checked<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n let packed = pack_checked::<A, BIT>(poly[j].coefficients);\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n inputs\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `pack::<A, BIT>` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::<BIT>()` and must match what `pack` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::<A, BIT>(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `[Field]` vector of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::<BIT>()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `pack` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::<BIT>()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `[Field]` vector where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Computes a cryptographic hash using the SAFE (Sponge API for Field Elements) protocol.\n///\n/// This is a convenience wrapper around the SAFE sponge API that handles the full\n/// lifecycle: initialization, absorption, squeezing, and finalization. It's designed\n/// for use in Fiat-Shamir challenge generation and commitment schemes within zero-knowledge circuits.\n///\n/// # Arguments\n/// * `domain_separator` - A 64-byte domain separator used to differentiate between\n/// different protocol instances and prevent cross-protocol attacks.\n/// * `inputs` - Vector of field elements to be absorbed into the sponge.\n/// * `io_pattern` - A 2-element array encoding the I/O pattern:\n/// - `io_pattern[0]`: Encoded ABSORB operation (MSB=1, lower 31 bits = length)\n/// - `io_pattern[1]`: Encoded SQUEEZE operation (MSB=0, lower 31 bits = length)\n///\n/// # Returns\n/// A vector of field elements squeezed from the sponge, with length determined by\n/// the SQUEEZE operation in the IO pattern.\n/// Proves `0 <= v < upper` using two one-sided bit-size checks.\n///\n/// `assert_max_bit_size` is one-sided: it forces a small **non-negative** field element. So bounding\n/// `v` gives `v >= 0`, and bounding `upper - 1 - v` gives `v <= upper - 1`. The pair composes into a\n/// two-sided interval without a comparison operator.\n///\n/// `BIT` must cover `upper`; the caller supplies it from the generated config.\npub fn assert_in_range<let BIT: u32>(v: Field, upper: Field) {\n v.assert_max_bit_size::<BIT>();\n (upper - 1 - v).assert_max_bit_size::<BIT>();\n}\n\npub fn compute_safe(domain_separator: [u8; 64], inputs: [Field], io_pattern: [u32; 2]) -> [Field] {\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let digests = sponge.squeeze();\n sponge.finish();\n\n digests\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert(result[0] == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result[1] == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result[2] == 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert(result[0] == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result[1] == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result[2] == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result[3] == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result[4] == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result[5] == 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result[0] == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result[1] == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result[2] == 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n\n#[test]\nfn test_safe_hashing_with_safe_helper() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let digests1 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests1.len() == 1);\n assert(digests1[0] != 0);\n\n // Test determinism\n let digests2 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests2.len() == 1);\n assert(digests2[0] != 0);\n assert(digests2[0] == digests1[0]);\n}\n\n#[test]\nfn test_pack() {\n // Test pack function directly with small values\n let values = [1, 2, 3, 4];\n let packed = pack::<4, 4>(values);\n\n // With BIT=4, nibble_bits=4, group should be floor(254/(4+4)) = 31\n // So all 4 values should fit in one carrier\n assert(packed.len() >= 1);\n\n // Test with negative values\n let values_neg = [-1, 2, -3, 4];\n let packed_neg = pack::<4, 4>(values_neg);\n assert(packed_neg.len() >= 1);\n}\n\n#[test]\nfn test_pack_single_value() {\n // Test packing a single value\n let values = [42];\n let packed = pack::<1, 8>(values);\n assert(packed.len() == 1);\n assert(packed[0] != 0);\n}\n\n#[test]\nfn test_pack_determinism() {\n // Test that packing is deterministic\n let values = [10, 20, 30];\n let packed1 = pack::<3, 8>(values);\n let packed2 = pack::<3, 8>(values);\n\n assert(packed1.len() == packed2.len());\n for i in 0..packed1.len() {\n assert(packed1[i] == packed2[i]);\n }\n}\n\n/// `pack_checked` must agree with `pack` for in-slot values. The two carry duplicate layout\n/// arithmetic, so if one is changed without the other, a commitment created by a circuit on `pack`\n/// stops matching one opened by a circuit on `pack_checked`. This pins that.\n#[test]\nfn test_pack_checked_matches_pack() {\n // Mixed signs, and values at the edge of the centred window for BIT = 35 (slot = 2^40).\n let vals: [Field; 7] = [0, 1, -1, 34359701504, -34359701504, 12345, -6789];\n let plain = pack::<7, 35>(vals);\n let checked = pack_checked::<7, 35>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n\n/// Same, at a width whose chunking leaves a partial final carrier (BIT = 57 -> group 3, 7 values).\n#[test]\nfn test_pack_checked_matches_pack_partial_chunk() {\n let vals: [Field; 7] = [5, -5, 72057594049265664, -72057594049265664, 1, 0, -1];\n let plain = pack::<7, 57>(vals);\n let checked = pack_checked::<7, 57>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n", path: "interfold/circuits/lib/src/math/helpers.nr", function_locations: [{ start: 1374, name: "packing_layout" }, { start: 3703, name: "pack_checked" }, { start: 4808, name: "flatten_checked" }, { start: 6096, name: "flatten" }, { start: 7946, name: "pack" }, { start: 10581, name: "assert_in_range" }, { start: 10770, name: "compute_safe" }, { start: 10968, name: "test_flatten" }, { start: 11911, name: "test_flatten_big" }, { start: 14812, name: "test_flatten_small" }, { start: 15639, name: "test_safe_hashing_with_safe_helper" }, { start: 16485, name: "test_pack" }, { start: 16955, name: "test_pack_single_value" }, { start: 17151, name: "test_pack_determinism" }, { start: 17749, name: "test_pack_checked_matches_pack" }, { start: 18287, name: "test_pack_checked_matches_pack_partial_chunk" }] }, "95": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse super::modulo::U128::ModU128;\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial<let N: u32> {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl<let N: u32> Polynomial<N> {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n /// Inner product of the coefficients with `k`, in the same index order.\n ///\n /// Paired with [`negacyclic_kernel`] this evaluates a product modulo `X^N + 1` without the\n /// product itself entering the witness.\n pub fn dot(self, k: [Field; N]) -> Field {\n let mut out: Field = 0;\n for j in 0..N {\n out += self.coefficients[j] * k[j];\n }\n out\n }\n\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point with modular reduction.\n ///\n /// This function computes `P(x) mod q` using Horner's method with intermediate\n /// modular reductions to prevent overflow. The result is guaranteed to be in\n /// the range `[0, q)`.\n ///\n /// The function performs modular reduction after each multiplication and addition\n /// to ensure the accumulator always remains in the range `[0, q)`, preventing\n /// any potential overflow issues.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial\n /// * `q` - The modular arithmetic context containing the modulus\n ///\n /// # Returns\n /// The value `P(x) mod q` in the range `[0, q)`\n pub fn eval_mod(self, x: Field, q: ModU128) -> Field {\n let mut acc = self.coefficients[0];\n let len = self.coefficients.len();\n\n for i in 1..len {\n acc = q.mul_mod(acc, x);\n acc = q.add(acc, self.coefficients[i]);\n }\n\n acc\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds.\n ///\n /// This function constrains all polynomial coefficients to be in the range [-lower_bound, upper_bound],\n /// where `lower_bound` is a non-negative magnitude.\n /// It uses a shifting technique to handle negative numbers efficiently:\n /// 1. Shifts each coefficient by adding `lower_bound`: c' = c + lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound + lower_bound] using bit-size assertions\n /// 3. This ensures original coefficients are in [-lower_bound, upper_bound]\n ///\n /// The function uses two bit-size checks per coefficient to ensure the value is within bounds:\n /// - `shifted_coefficient.assert_max_bit_size::<BIT + 1>()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>()` ensures c' <= range_size\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - Non-negative magnitude of the negative bound\n /// Coefficients must satisfy: -lower_bound <= c <= upper_bound\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length of the total range `upper_bound + lower_bound`\n /// (choose `BIT` so `upper_bound + lower_bound < 2^BIT`). Since all checked\n /// values lie in `[0, upper_bound + lower_bound]`, they cannot exceed `BIT + 1` bits.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the specified bounds.\n pub fn range_check_2bounds<let BIT: u32>(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::<BIT + 1>();\n (range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, upper_bound).\n ///\n /// This function constrains all polynomial coefficients to be non-negative and\n /// strictly less than `upper_bound`. It uses bit-size assertions to verify that\n /// coefficients are in the valid range.\n ///\n /// The function performs two checks per coefficient:\n /// 1. `coeff.assert_max_bit_size::<BIT>()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::<BIT>()` ensures `coeff < upper_bound`\n ///\n /// # Arguments\n /// * `upper_bound` - The exclusive upper bound for coefficient range checking.\n /// Coefficients must satisfy: `0 <= c < upper_bound`\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Must satisfy `upper_bound <= 2^BIT` for\n /// the range check to work correctly.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, upper_bound)`.\n pub fn range_check_standard<let BIT: u32>(self, upper_bound: Field) {\n for i in 0..self.coefficients.len() {\n let coeff = self.coefficients[i];\n // Check coeff >= 0 and coeff < 2^BIT\n coeff.assert_max_bit_size::<BIT>();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::<BIT>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, 2^BIT).\n ///\n /// This is a specialized range check for coefficients that must be non-negative\n /// and less than a power of two. It's more efficient than `range_check_standard`\n /// when the upper bound is exactly `2^BIT` because it only needs a single\n /// bit-size assertion per coefficient.\n ///\n /// The function verifies that each coefficient satisfies:\n /// - `coeff >= 0` (implicit from bit-size check)\n /// - `coeff < 2^BIT` (enforced by `assert_max_bit_size::<BIT>()`)\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Coefficients must satisfy: `0 <= c < 2^BIT`\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, 2^BIT)`.\n pub fn range_check_power_of_two<let BIT: u32>(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::<BIT>();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert(result == 0);\n}\n\n/// Evaluation kernel for `u` modulo `X^N + 1`: `out[j]` is `(X^(N-1-j) * u mod X^N + 1)(x)`.\n///\n/// `a.dot(negacyclic_kernel(u, x))` then equals `(a * u mod X^N + 1)(x)` without the prover\n/// supplying the product, so no product witness has to be bound or range-checked.\npub fn negacyclic_kernel<let N: u32>(u: Polynomial<N>, x: Field) -> [Field; N] {\n assert(N > 0);\n let phi = x.pow_32(N as Field) + 1;\n let mut out = [0; N];\n out[N - 1] = u.eval(x);\n for j in 1..N {\n out[N - 1 - j] = x * out[N - j] - phi * u.coefficients[j - 1];\n }\n out\n}\n\n#[test]\nfn test_negacyclic_kernel_matches_reduced_product() {\n let a = Polynomial::new([4, 3, 2, 1]);\n let u = Polynomial::new([-1, 0, 1, -1]);\n\n // Schoolbook product, then reduced by hand with X^4 = -1.\n let mut prod = [0; 7];\n for i in 0..4 {\n for j in 0..4 {\n prod[i + j] += a.coefficients[i] * u.coefficients[j];\n }\n }\n let reduced = Polynomial::new([prod[3], prod[4] - prod[0], prod[5] - prod[1], prod[6] - prod[2]]);\n\n let points: [Field; 4] = [0, 1, 2, 17];\n for j in 0..4 {\n let x = points[j];\n assert(a.dot(negacyclic_kernel(u, x)) == reduced.eval(x));\n }\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_polynomial_add() {\n let coeffs1 = [1, 2, 3]; // 1x^2 + 2x + 3\n let coeffs2 = [4, 5, 6]; // 4x^2 + 5x + 6\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.add(poly2);\n\n // Expected: (1+4)x^2 + (2+5)x + (3+6) = 5x^2 + 7x + 9\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 7);\n assert(result.coefficients[2] == 9);\n}\n\n#[test]\nfn test_polynomial_sub() {\n let coeffs1 = [5, 7, 9]; // 5x^2 + 7x + 9\n let coeffs2 = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.sub(poly2);\n\n // Expected: (5-1)x^2 + (7-2)x + (9-3) = 4x^2 + 5x + 6\n assert(result.coefficients[0] == 4);\n assert(result.coefficients[1] == 5);\n assert(result.coefficients[2] == 6);\n}\n\n#[test]\nfn test_polynomial_mul_scalar() {\n let coeffs = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n let scalar = 5;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 5x^2 + 10x + 15\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 10);\n assert(result.coefficients[2] == 15);\n}\n\n#[test]\nfn test_polynomial_mul_scalar_zero() {\n let coeffs = [1, 2, 3];\n let poly = Polynomial::new(coeffs);\n let scalar = 0;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 0x^2 + 0x + 0 = 0\n assert(result.coefficients[0] == 0);\n assert(result.coefficients[1] == 0);\n assert(result.coefficients[2] == 0);\n}\n\n#[test]\nfn test_eval_mod_simple() {\n // Test without initial reduction - simple case\n // p(x) = x + 1 at x=5od 7\n // Expected: (5 + 1) mod 7 = 6\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 1]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 6);\n\n // Test: p(x) = 2x + 3 at x=5od 7\n // Expected: (10 + 3) mod 7 = 13 mod 7 = 6\n let poly2 = Polynomial::new([2, 3]);\n let result2 = poly2.eval_mod(5, q);\n assert(result2 == 6);\n}\n\n#[test]\nfn test_eval_mod() {\n // Test 1: Simple polynomial x^2 + 2x + 3 at x=5od 7\n // Expected: (25 + 10 + 3) mod 7 = 38 mod 7 = 3\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 2, 3]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 3);\n\n // Test 2: Higher degree polynomialod small prime\n // p(x) = x^3 + x^2 + x + 1 at x=2od 11\n // Expected: (8 + 4 + 2 + 1) mod 11 = 15 mod 11 = 4\n let q = ModU128::new(11);\n\n let poly2 = Polynomial::new([1, 1, 1, 1]);\n let result2 = poly2.eval_mod(2, q);\n assert(result2 == 4);\n\n // Test 3: Polynomial with larger coefficients\n // p(x) = 100x^2 + 50x + 25 at x=10od 73\n // Expected: (10000 + 500 + 25) mod 73 = 10525 mod 73 = 13\n let q = ModU128::new(73);\n\n let poly3 = Polynomial::new([100, 50, 25]);\n let result3 = poly3.eval_mod(10, q);\n assert(result3 == 13);\n\n // Test 4: Result should be less than modulus\n let poly4 = Polynomial::new([5, 3, 7]);\n let q = ModU128::new(17);\n let result4 = poly4.eval_mod(4, q);\n assert(result4 as u128 < q.get_mod_field() as u128);\n\n // Test 5: Compare with regular eval for small values\n let poly5 = Polynomial::new([1, 2, 1]);\n let x = 3;\n let q = ModU128::new(1000);\n let result5 = poly5.eval_mod(x, q);\n let expected5 = poly5.eval(x);\n assert(result5 == expected5);\n\n // Test 6: Zero polynomial\n let poly6 = Polynomial::new([0, 0, 0]);\n let q = ModU128::new(13);\n let result6 = poly6.eval_mod(100, q);\n assert(result6 == 0);\n}\n\n#[test]\nfn test_large_party_ids_scenario() {\n // Simulating party IDs in range [1, 100]\n let party_id_1 = 42;\n let party_id_2 = 73;\n let m = ModU128::new(288230376151711717); // ~58 bits\n\n // Operations that would be used in Lagrange coefficients\n let product = m.mul_mod(party_id_1, party_id_2);\n let diff = m.sub(party_id_2, party_id_1);\n\n assert(product == 3066);\n assert(diff == 31);\n}\n\n#[test]\nfn test_eval_vs_eval_mod() {\n // Compare eval and eval_mod for small values where no reduction should occur\n let poly = Polynomial::new([1, 2, 3]);\n let x = 2;\n let q = ModU128::new(1000); // Large enough that no reduction happens\n\n let result_normal = poly.eval(x);\n let result_mod = poly.eval_mod(x, q);\n\n // They should be equal: (1)*2 + 2)*2 + 3 = (2+2)*2 + 3 = 4*2 + 3 = 11\n assert(result_normal == 11);\n assert(result_mod == 11);\n}\n", path: "interfold/circuits/lib/src/math/polynomial.nr", function_locations: [{ start: 1261, name: "Polynomial<N>::new" }, { start: 1555, name: "Polynomial<N>::add" }, { start: 2008, name: "Polynomial<N>::sub" }, { start: 2481, name: "Polynomial<N>::mul_scalar" }, { start: 3426, name: "Polynomial<N>::dot" }, { start: 3602, name: "Polynomial<N>::eval" }, { start: 4576, name: "Polynomial<N>::eval_mod" }, { start: 6506, name: "Polynomial<N>::range_check_2bounds" }, { start: 7992, name: "Polynomial<N>::range_check_standard" }, { start: 9247, name: "Polynomial<N>::range_check_power_of_two" }, { start: 9416, name: "test_polynomial_eval_zero" }, { start: 9976, name: "negacyclic_kernel" }, { start: 10259, name: "test_negacyclic_kernel_matches_reduced_product" }, { start: 10873, name: "test_polynomial_bounds" }, { start: 11156, name: "test_polynomial_out_of_bounds_coefficients" }, { start: 11411, name: "test_polynomial_add" }, { start: 11844, name: "test_polynomial_sub" }, { start: 12284, name: "test_polynomial_mul_scalar" }, { start: 12641, name: "test_polynomial_mul_scalar_zero" }, { start: 12970, name: "test_eval_mod_simple" }, { start: 13450, name: "test_eval_mod" }, { start: 15008, name: "test_large_party_ids_scenario" }, { start: 15418, name: "test_eval_vs_eval_mod" }] }, "97": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\nuse poseidon::poseidon2_permutation;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// "SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge<let L: u32> {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl<let L: u32> SafeSponge<L> {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge<L> {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: [Field]) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, "Expected ABSORB operation");\n assert(expected_length == length, "Length mismatch");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input[i];\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> [Field] {\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, "Expected SQUEEZE operation");\n\n let mut output: [Field] = [].as_vector();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won\'t execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output = output.push_back(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, "IO pattern not completed");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge\'s usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag<let L: u32>(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Buffer is 256 bytes: max 192 bytes for IO pattern (48 words) + 64 bytes for domain separator.\n // Note: We must use a fixed-size array because Noir\'s keccak256 requires [u8; N], not [u8].\n let max_io_pattern_bytes: u32 = 192; // 256 - 64 (domain separator)\n let io_pattern_bytes = word_count * 4;\n assert(\n io_pattern_bytes <= max_io_pattern_bytes,\n "IO pattern too large: max 48 aggregated words supported",\n );\n\n let mut input_bytes = [0u8; 256];\n let mut byte_count: u32 = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n // Note: Noir requires compile-time loop bounds, so we iterate over L (the array size)\n // instead of word_count (runtime value). The condition `i < word_count` ensures we only\n // process valid encoded words. This is safe because word_count <= L always holds\n // (we can have at most L encoded words from L input operations).\n for i in 0..L {\n if i < word_count {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append full 64-byte domain separator.\n for i in 0..64 {\n input_bytes[byte_count] = domain_separator[i];\n byte_count += 1;\n }\n\n // Step 3: Hash with Keccak-256 and truncate to 128 bits.\n // Note: The SAFE spec uses SHA3-256, but we use Keccak-256 for Noir compatibility.\n // Keccak-256 differs from SHA3-256 in padding, but both provide equivalent security.\n let hash_bytes = keccak256(input_bytes, byte_count);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = [123].as_vector();\n let right = [456].as_vector();\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = [10, 20, 30].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = [1, 2, 3].as_vector();\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1[0] != output2[0]); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output[0] != 0);\n assert(output[1] != 0);\n assert(output[0] != output[1]); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb([].as_vector());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println("=== SAFE Tag Computation Debug Test ===");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f"Testing pattern: {io_pattern}");\n println(\n f"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)",\n );\n println(\n f"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]",\n );\n println("");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f"=== Expected Rust Output ===");\n println("Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))");\n println("Domain separator: 0x41424344...");\n println("Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a");\n println("");\n\n println(f"=== Noir Output ===");\n println(f"Tag: {tag}");\n println("");\n\n println("Compare the tag values above with Rust script!");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Consecutive ABSORB operations should aggregate to the same tag");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive ABSORB operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive ABSORB Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n "Consecutive SQUEEZE operations should aggregate to the same tag",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive SQUEEZE operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive SQUEEZE Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Mixed consecutive operations should aggregate to the same tag");\n\n println("=== Mixed Consecutive Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]",\n );\n println(\n f" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))",\n );\n println(f"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]");\n println(f" (ABSORB(2), SQUEEZE(2), ABSORB(1))");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n}\n\n#[test]\nfn test_large_io_pattern() {\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Create pattern with 48 alternating ABSORB(1) and SQUEEZE(1) operations\n // This is the maximum supported (48 words * 4 bytes = 192 bytes, leaving 64 for domain separator)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1; // ABSORB(1)\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1; // SQUEEZE(1)\n }\n }\n\n let tag = compute_tag(io_pattern, domain_separator);\n assert(tag != 0);\n}\n\n#[test]\nfn test_domain_separator_not_truncated() {\n // This test verifies that the domain separator is always included in the tag computation,\n // even for large IO patterns. If the domain separator were truncated, different domain\n // separators would produce the same tag for large patterns.\n\n let domain_separator_a = [\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41,\n ]; // All \'A\'s\n\n let domain_separator_b = [\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42,\n ]; // All \'B\'s\n\n // Create pattern with 48 alternating operations (max supported: 192 bytes of IO pattern)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1;\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1;\n }\n }\n\n let tag_a = compute_tag(io_pattern, domain_separator_a);\n let tag_b = compute_tag(io_pattern, domain_separator_b);\n\n // Tags MUST be different because domain separators are different.\n // If they were the same, it would mean the domain separator was truncated/ignored.\n assert(tag_a != tag_b, "Domain separator must affect tag even for large IO patterns");\n}\n', path: "interfold/circuits/lib/src/math/safe.nr", function_locations: [{ start: 4164, name: "SafeSponge<L>::start" }, { start: 5046, name: "SafeSponge<L>::absorb" }, { start: 6826, name: "SafeSponge<L>::squeeze" }, { start: 8494, name: "SafeSponge<L>::finish" }, { start: 9156, name: "SafeSponge<L>::permute" }, { start: 9830, name: "compute_tag" }, { start: 14128, name: "test_safe_hashing" }, { start: 15104, name: "test_merkle_node" }, { start: 16281, name: "test_commitment_scheme" }, { start: 17357, name: "test_domain_separation" }, { start: 18710, name: "test_multiple_squeeze" }, { start: 19639, name: "test_zero_length_operations" }, { start: 20415, name: "test_tag_computation" }, { start: 21477, name: "test_tag_computation_debug" }, { start: 22681, name: "test_consecutive_absorb_aggregation" }, { start: 24750, name: "test_consecutive_squeeze_aggregation" }, { start: 26760, name: "test_mixed_consecutive_aggregation" }, { start: 28520, name: "test_large_io_pattern" }, { start: 29333, name: "test_domain_separator_not_truncated" }] } } };
9
+
10
+ // ../../circuits/dist/insecure-64/user_data_encryption_ct1.json
11
+ var user_data_encryption_ct1_default = { noir_version: "1.0.0-beta.26+40d6574f851d926f93e0c3a271bac3e6e82ac905", hash: "8995229096591725754", abi: { parameters: [{ name: "pk1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "ct1is", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }, { name: "u", type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "e1", type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] }, visibility: "private" }, { name: "r_ct1", type: { kind: "array", length: 3, type: { kind: "struct", path: "lib::math::polynomial::Polynomial", fields: [{ name: "coefficients", type: { kind: "array", length: 64, type: { kind: "field" } } }] } }, visibility: "private" }], return_type: { abi_type: { kind: "tuple", fields: [{ kind: "field" }, { kind: "field" }, { kind: "field" }] }, visibility: "public" }, error_types: { "12469291177396340830": { error_kind: "string", string: "call to assert_max_bit_size" }, "18258692384630939949": { error_kind: "string", string: "ct1 encryption check failed" } } }, bytecode: "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", debug_symbols: "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", file_map: { "16": { 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', path: "std/field/mod.nr", function_locations: [{ start: 380, name: "Field::assert_max_bit_size" }, { start: 1196, name: "Field::to_le_bits" }, { start: 2387, name: "Field::to_be_bits" }, { start: 3562, name: "Field::to_le_bytes" }, { start: 5033, name: "Field::to_be_bytes" }, { start: 5904, name: "Field::to_le_radix" }, { start: 6362, name: "Field::to_be_radix" }, { start: 7053, name: "Field::pow_32" }, { start: 7455, name: "Field::sgn0" }, { start: 7538, name: "Field::lt" }, { start: 8073, name: "Field::from_le_bytes" }, { start: 8820, name: "Field::from_be_bytes" }, { start: 9611, name: "Field::from_le_bytes_checked" }, { start: 10620, name: "Field::from_be_bytes_checked" }, { start: 11202, name: "__assert_max_bit_size" }, { start: 11330, name: "__to_le_radix" }, { start: 11458, name: "__to_be_radix" }, { start: 12179, name: "__to_le_bits" }, { start: 12897, name: "__to_be_bits" }, { start: 12972, name: "modulus_num_bits" }, { start: 13048, name: "modulus_be_bits" }, { start: 13124, name: "modulus_le_bits" }, { start: 13200, name: "modulus_be_bytes" }, { start: 13276, name: "modulus_le_bytes" }, { start: 13437, name: "__field_less_than" }, { start: 13513, name: "field_less_than" }, { start: 13589, name: "lt_fallback" }, { start: 14551, name: "tests::test_to_be_bits" }, { start: 14824, name: "tests::test_to_le_bits" }, { start: 15099, name: "tests::test_to_be_bytes" }, { start: 15405, name: "tests::test_to_le_bytes" }, { start: 15711, name: "tests::test_to_be_radix" }, { start: 16293, name: "tests::test_to_le_radix" }, { start: 16893, name: "tests::test_to_le_radix_1" }, { start: 17346, name: "tests::test_to_le_radix_brillig_1" }, { start: 17700, name: "tests::test_to_le_radix_3" }, { start: 18011, name: "tests::test_to_le_radix_brillig_3" }, { start: 18439, name: "tests::test_to_le_radix_512" }, { start: 18848, name: "tests::not_enough_limbs_brillig" }, { start: 19044, name: "tests::not_enough_limbs" }, { start: 19274, name: "tests::non_zero_field_to_le_bytes_zero_limbs" }, { start: 19469, name: "tests::non_zero_field_to_be_bytes_zero_limbs" }, { start: 19600, name: "tests::zero_field_to_bytes_zero_limbs_unconstrained" }, { start: 19915, name: "tests::zero_field_to_bytes_zero_limbs_constrained" }, { start: 20227, name: "tests::zero_field_to_bytes_zero_limbs_comptime" }, { start: 20558, name: "tests::test_field_less_than" }, { start: 20813, name: "tests::test_large_field_values_unconstrained" }, { start: 21266, name: "tests::test_large_field_values" }, { start: 21713, name: "tests::test_decomposition_edge_cases" }, { start: 22303, name: "tests::test_pow_32" }, { start: 22632, name: "tests::test_sgn0" }, { start: 23054, name: "tests::test_bit_decomposition_overflow" }, { start: 23336, name: "tests::test_byte_decomposition_overflow" }, { start: 23553, name: "tests::test_to_from_be_bytes_bn254_edge_cases" }, { start: 25504, name: "tests::test_to_from_le_bytes_bn254_edge_cases" }, { start: 27439, name: "tests::test_from_le_bytes_checked_accepts_modulus_minus_one" }, { start: 27918, name: "tests::test_from_le_bytes_checked_rejects_modulus" }, { start: 28303, name: "tests::test_from_le_bytes_checked_rejects_modulus_plus_one" }, { start: 28758, name: "tests::test_from_be_bytes_checked_accepts_modulus_minus_one" }, { start: 29247, name: "tests::test_from_be_bytes_checked_rejects_modulus" }, { start: 29632, name: "tests::test_from_be_bytes_checked_rejects_modulus_plus_one" }, { start: 30076, name: "tests::test_from_bytes_checked_small_n" }, { start: 30721, name: "tests::from_le_bits" }, { start: 31268, name: "tests::from_be_bits" }, { start: 31514, name: "tests::test_to_from_be_bits_bn254_edge_cases" }, { start: 33447, name: "tests::test_to_from_le_bits_bn254_edge_cases" }, { start: 35379, name: "tests::max_bit_size_too_large" }] }, "17": { 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', path: "std/hash/mod.nr", function_locations: [{ start: 572, name: "sha256_compression" }, { start: 707, name: "keccakf1600" }, { start: 852, name: "blake2s" }, { start: 950, name: "blake3" }, { start: 1437, name: "__blake3" }, { start: 1555, name: "pedersen_commitment" }, { start: 1784, name: "pedersen_commitment_with_separator" }, { start: 2188, name: "pedersen_hash" }, { start: 2345, name: "pedersen_hash_with_separator" }, { start: 3339, name: "derive_generators" }, { start: 3698, name: "__derive_generators" }, { start: 3776, name: "poseidon2_permutation" }, { start: 4132, name: "poseidon2_permutation_internal" }, { start: 4225, name: "poseidon2_config_state_size" }, { start: 4536, name: "derive_hash" }, { start: 5327, name: "Hasher::finish_ref" }, { start: 5761, name: "<impl BuildHasher for BuildHasherDefault<H>>::build_hasher" }, { start: 5893, name: "<impl Default for BuildHasherDefault<H>>::default" }, { start: 6025, name: "<impl Hash for Field>::hash" }, { start: 6155, name: "<impl Hash for u8>::hash" }, { start: 6295, name: "<impl Hash for u16>::hash" }, { start: 6435, name: "<impl Hash for u32>::hash" }, { start: 6575, name: "<impl Hash for u64>::hash" }, { start: 6716, name: "<impl Hash for u128>::hash" }, { start: 6855, name: "<impl Hash for i8>::hash" }, { start: 7001, name: "<impl Hash for i16>::hash" }, { start: 7148, name: "<impl Hash for i32>::hash" }, { start: 7295, name: "<impl Hash for i64>::hash" }, { start: 7443, name: "<impl Hash for bool>::hash" }, { start: 7590, name: "<impl Hash for ()>::hash" }, { start: 7722, name: "<impl Hash for [T; N]>::hash" }, { start: 7911, name: "<impl Hash for [T]>::hash" }, { start: 8133, name: "<impl Hash for (A,)>::hash" }, { start: 8302, name: "<impl Hash for (A, B)>::hash" }, { start: 8518, name: "<impl Hash for (A, B, C)>::hash" }, { start: 8781, name: "<impl Hash for (A, B, C, D)>::hash" }, { start: 9091, name: "<impl Hash for (A, B, C, D, E)>::hash" }, { start: 9448, name: "<impl Hash for (A, B, C, D, E, F)>::hash" }, { start: 9852, name: "<impl Hash for (A, B, C, D, E, F, G)>::hash" }, { start: 10306, name: "<impl Hash for (A, B, C, D, E, F, G, H_)>::hash" }, { start: 10807, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I)>::hash" }, { start: 11355, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J)>::hash" }, { start: 11950, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K)>::hash" }, { start: 12593, name: "<impl Hash for (A, B, C, D, E, F, G, H_, I, J, K, L)>::hash" }, { start: 13187, name: "assert_pedersen" }] }, "52": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse lib::configs::default::threshold::{\n L, N, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_E1, USER_DATA_ENCRYPTION_BIT_PK,\n USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_CT1_BIT_R, USER_DATA_ENCRYPTION_CT1_CONFIGS,\n};\nuse lib::core::threshold::user_data_encryption_ct1::UserDataEncryptionCt1;\nuse lib::math::polynomial::Polynomial;\n\nfn main(\n pk1is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n u: Polynomial<N>,\n e1: Polynomial<N>,\n // Named `r_ct1` only because ct0 and ct1 share one generated Prover.toml and each needs its\n // own reduction quotient; the circuit field it feeds is `r`.\n r_ct1: [Polynomial<N>; L],\n) -> pub (Field, Field, Field) {\n let circuit: UserDataEncryptionCt1<N, L, USER_DATA_ENCRYPTION_BIT_PK, USER_DATA_ENCRYPTION_BIT_CT, USER_DATA_ENCRYPTION_BIT_U, USER_DATA_ENCRYPTION_BIT_E1, USER_DATA_ENCRYPTION_CT1_BIT_R> =\n UserDataEncryptionCt1::new(USER_DATA_ENCRYPTION_CT1_CONFIGS, pk1is, ct1is, u, e1, r_ct1);\n\n circuit.execute()\n}\n", path: "interfold/circuits/bin/threshold/user_data_encryption_ct1/src/main.nr", function_locations: [{ start: 883, name: "main" }] }, "84": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! User-data encryption - ct1 leg (P3).\n//!\n//! See `UserDataEncryptionCt1` for the circuit contract.\n\nuse crate::math::commitments::compute_multiple_polynomial_commitment;\nuse crate::math::commitments::compute_single_polynomial_commitment;\nuse crate::math::commitments::compute_user_data_encryption_ct1_challenge;\nuse crate::math::commitments::DS_CIPHERTEXT;\nuse crate::math::commitments::DS_PK_AGGREGATION;\nuse crate::math::commitments::DS_USER_DATA_ENCRYPTION_COMMITMENT;\nuse crate::math::helpers::flatten;\nuse crate::math::polynomial::{negacyclic_kernel, Polynomial};\n\n/// Parameters for user-data encryption ct1 (P3).\npub struct Configs<let N: u32, let L: u32> {\n pub qis: [Field; L],\n pub e1_bound: Field,\n pub u_bound: Field,\n /// Bound on `r`, the quotient of the mod-`q` reduction.\n pub r_bounds: [Field; L],\n}\nimpl<let N: u32, let L: u32> Configs<N, L> {\n pub fn new(qis: [Field; L], e1_bound: Field, u_bound: Field, r_bounds: [Field; L]) -> Self {\n Configs { qis, e1_bound, u_bound, r_bounds }\n }\n}\n\n/// User-data encryption ct1 (P3).\n///\n/// **Role:** Second ciphertext leg; `u` must match the ct0 `u_commitment`.\n///\n/// **Produces:** `(pk1_commitment, ct1_commitment, u_commitment)` public outputs.\npub struct UserDataEncryptionCt1<let N: u32, let L: u32, let BIT_PK: u32, let BIT_CT: u32, let BIT_U: u32, let BIT_E1: u32, let BIT_R: u32> {\n configs: Configs<N, L>,\n pk1is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n /// Re-witnessed privately; checked against `u_commitment` from ct0 (same P3 flow).\n u: Polynomial<N>,\n e1: Polynomial<N>,\n /// Quotient of the mod-`q` reduction, already reduced modulo `X^N + 1` by the prover. Degree `N`\n /// rather than `2N - 1`, and the cyclotomic quotient the unreduced identity needed is gone\n /// entirely, because `X^N = -1` makes its term identically zero.\n r: [Polynomial<N>; L],\n}\n\nimpl<let N: u32, let L: u32, let BIT_PK: u32, let BIT_CT: u32, let BIT_U: u32, let BIT_E1: u32, let BIT_R: u32> UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R> {\n\n pub fn new(\n configs: Configs<N, L>,\n pk1is: [Polynomial<N>; L],\n ct1is: [Polynomial<N>; L],\n u: Polynomial<N>,\n e1: Polynomial<N>,\n r: [Polynomial<N>; L],\n ) -> Self {\n UserDataEncryptionCt1 { configs, pk1is, ct1is, u, e1, r }\n }\n\n /// Bounds every value the reduced identity is checked over.\n ///\n /// The identity is verified at one random point, so each coefficient needs a bound for the\n /// field equality to imply the integer one. `pk1is` / `ct1is` are centered residues mod `q_i`;\n /// `u` finally uses `configs.u_bound`, which the unreduced path left unread.\n fn check_range_bounds(self) {\n self.e1.range_check_2bounds::<BIT_E1>(self.configs.e1_bound, self.configs.e1_bound);\n self.u.range_check_2bounds::<BIT_U>(self.configs.u_bound, self.configs.u_bound);\n\n for i in 0..L {\n let half = (self.configs.qis[i] - 1) / 2;\n self.pk1is[i].range_check_2bounds::<BIT_PK>(half, half);\n self.ct1is[i].range_check_2bounds::<BIT_CT>(half, half);\n self.r[i].range_check_2bounds::<BIT_R>(\n self.configs.r_bounds[i],\n self.configs.r_bounds[i],\n );\n }\n }\n\n fn generate_commitments(self) -> (Field, Field, Field) {\n // `check_range_bounds` bounds `pk1is`, `ct1is` and `u`, so the plain packing is already\n // injective for all three and the digit asserts would be redundant.\n let pk1_commitment =\n compute_multiple_polynomial_commitment::<N, L, BIT_PK>(self.pk1is, DS_PK_AGGREGATION);\n let ct1_commitment =\n compute_multiple_polynomial_commitment::<N, L, BIT_CT>(self.ct1is, DS_CIPHERTEXT);\n let u_commitment = compute_single_polynomial_commitment::<N, BIT_U>(\n self.u,\n DS_USER_DATA_ENCRYPTION_COMMITMENT,\n );\n\n (pk1_commitment, ct1_commitment, u_commitment)\n }\n\n fn generate_challenge(\n self,\n pk1_commitment: Field,\n ct1_commitment: Field,\n u_commitment: Field,\n ) -> [Field] {\n let mut payload = [pk1_commitment, ct1_commitment, u_commitment].as_vector();\n\n payload = flatten::<_, _, BIT_E1>(payload, [self.e1]);\n // `r` replaces `p1is` and `p2is` in the transcript, and it is bounded, so the plain packing\n // stays injective.\n payload = flatten::<_, _, BIT_R>(payload, self.r);\n\n compute_user_data_encryption_ct1_challenge::<L>(payload)\n }\n\n /// Checks `ct1is = pk1is * u + e1 + q_i * r` modulo `X^N + 1`, at one challenge point.\n ///\n /// `negacyclic_kernel` supplies the reduced product `pk1is * u mod X^N + 1` evaluated at `x`, so\n /// the product never enters the witness and the cyclotomic quotient is gone with it.\n fn verify_evaluations(self, gammas: [Field]) -> bool {\n let x = gammas[0];\n let k = negacyclic_kernel(self.u, x);\n\n let mut holds = true;\n for i in 0..L {\n let mut residual = [0; N];\n for j in 0..N {\n residual[j] = self.ct1is[i].coefficients[j]\n - self.e1.coefficients[j]\n - self.configs.qis[i] * self.r[i].coefficients[j];\n }\n holds = holds & (Polynomial::new(residual).eval(x) == self.pk1is[i].dot(k));\n }\n\n holds\n }\n\n /// Returns `(pk1_commitment, ct1_commitment, u_commitment)`.\n pub fn execute(self) -> (Field, Field, Field) {\n // Step 1: bound everything the reduced identity is read over.\n self.check_range_bounds();\n\n // Step 2: Commitments for the FS transcript.\n let (pk1_commitment, ct1_commitment, u_commitment) = self.generate_commitments();\n\n // Step 3: Fiat-Shamir challenge and evaluation check of the reduced ct1 equation.\n let gammas = self.generate_challenge(pk1_commitment, ct1_commitment, u_commitment);\n\n assert(self.verify_evaluations(gammas), "ct1 encryption check failed");\n\n (pk1_commitment, ct1_commitment, u_commitment)\n }\n}\n\n/// IF-013 / reduced identity: a `u` outside `u_bound` is rejected.\n///\n/// Before the reduced path, ct1 bounded `u` nowhere: it relied on ct0\'s bound reaching it through the\n/// equality the `user_data_encryption` fold asserts between the two `u` commitments, and the plain\n/// packing let a carry (`+delta` in slot 0, `-radix * delta` in slot 1) satisfy that equality with\n/// different randomness. The reduced identity needs `u` bounded in its own right \u2014 the field equality\n/// at one point only implies the integer one when every coefficient is bounded \u2014 so `configs.u_bound`\n/// is finally read, and the shifted `u` is now rejected outright rather than via its commitment.\n#[test(should_fail)]\nfn u_outside_its_bound_is_rejected() {\n let z = Polynomial::new([0; 8]);\n let one = Polynomial::new([0, 0, 0, 0, 0, 0, 0, 1]);\n let mut c: UserDataEncryptionCt1<8, 1, 35, 35, 1, 5, 9> = UserDataEncryptionCt1::new(\n Configs::new([68719403009], 32, 1, [5]),\n [one],\n [one],\n z,\n z,\n [Polynomial::new([0; 8])],\n );\n c.u.coefficients[0] = 1000;\n let _ = c.execute();\n}\n\n/// An honest witness satisfies the reduced identity, with a nonzero `r`.\n///\n/// Worked by hand at `N = 4`, `q = 97`: `pk1 * u mod X^4 + 1` is `[-50, -30, -10, -50]`, plus\n/// `e1 = [0, 0, 0, 1]` gives `[-50, -30, -10, -49]`. Two coefficients fall below `-(q-1)/2`, so the\n/// centered ciphertext is `[47, -30, -10, 48]` and the reduction quotient is `r = [1, 0, 0, 1]`.\n#[test]\nfn honest_reduced_identity_holds() {\n let pk1 = Polynomial::new([30, 40, -20, 10]);\n let u = Polynomial::new([0, 1, 0, -1]);\n let e1 = Polynomial::new([0, 0, 0, 1]);\n let ct1 = Polynomial::new([47, -30, -10, 48]);\n let r = Polynomial::new([1, 0, 0, 1]);\n\n let c: UserDataEncryptionCt1<4, 1, 6, 6, 1, 1, 3> =\n UserDataEncryptionCt1::new(Configs::new([97], 1, 1, [3]), [pk1], [ct1], u, e1, [r]);\n let _ = c.execute();\n}\n', path: "interfold/circuits/lib/src/core/threshold/user_data_encryption_ct1.nr", function_locations: [{ start: 1165, name: "Configs<N, L>::new" }, { start: 2491, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::new" }, { start: 2949, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::check_range_bounds" }, { start: 3577, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::generate_commitments" }, { start: 4373, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::generate_challenge" }, { start: 5135, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::verify_evaluations" }, { start: 5760, name: "UserDataEncryptionCt1<N, L, BIT_PK, BIT_CT, BIT_U, BIT_E1, BIT_R>::execute" }, { start: 7084, name: "u_outside_its_bound_is_rejected" }, { start: 7888, name: "honest_reduced_identity_holds" }] }, "86": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse crate::math::helpers::{compute_safe, flatten, flatten_checked};\nuse crate::math::polynomial::Polynomial;\n\n/// DOMAIN SEPARATORS\n\n// Domain separator - "PK"\npub global DS_PK: [u8; 64] = [\n 0x50, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_GENERATION"\npub global DS_PK_GENERATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_COMPUTATION"\npub global DS_SHARE_COMPUTATION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 0x50, 0x55, 0x54, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "SHARE_ENCRYPTION"\npub global DS_SHARE_ENCRYPTION: [u8; 64] = [\n 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "PK_AGGREGATION"\npub global DS_PK_AGGREGATION: [u8; 64] = [\n 0x50, 0x4b, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CIPHERTEXT"\npub global DS_CIPHERTEXT: [u8; 64] = [\n 0x43, 0x49, 0x50, 0x48, 0x45, 0x52, 0x54, 0x45, 0x58, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "AGGREGATED_SHARES"\npub global DS_AGGREGATED_SHARES: [u8; 64] = [\n 0x41, 0x47, 0x47, 0x52, 0x45, 0x47, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45,\n 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "VK_HASH"\npub global DS_VK_HASH: [u8; 64] = [\n 0x56, 0x4b, 0x5f, 0x48, 0x41, 0x53, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "RECURSIVE_AGGREGATION"\npub global DS_RECURSIVE_AGGREGATION: [u8; 64] = [\n 0x52, 0x45, 0x43, 0x55, 0x52, 0x53, 0x49, 0x56, 0x45, 0x5f, 0x41, 0x47, 0x47, 0x52, 0x45, 0x47,\n 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_PK_GENERATION"\npub global DS_CLG_PK_GENERATION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x50, 0x4b, 0x5f, 0x47, 0x45, 0x4e, 0x45, 0x52, 0x41, 0x54, 0x49, 0x4f,\n 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_ENCRYPTION"\npub global DS_CLG_SHARE_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_USER_DATA_ENCRYPTION"\npub global DS_CLG_USER_DATA_ENCRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e,\n 0x43, 0x52, 0x59, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n// Domain separator - "CLG_SHARE_DECRYPTION"\npub global DS_CLG_SHARE_DECRYPTION: [u8; 64] = [\n 0x43, 0x4c, 0x47, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "THRESHOLD_DECRYPTION_SHARE"\npub global DS_THRESHOLD_DECRYPTION_SHARE: [u8; 64] = [\n 0x54, 0x48, 0x52, 0x45, 0x53, 0x48, 0x4f, 0x4c, 0x44, 0x5f, 0x44, 0x45, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x48, 0x41, 0x52, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n// Domain separator - "USER_DATA_ENCRYPTION_COMMITMENT"\npub global DS_USER_DATA_ENCRYPTION_COMMITMENT: [u8; 64] = [\n 0x55, 0x53, 0x45, 0x52, 0x5f, 0x44, 0x41, 0x54, 0x41, 0x5f, 0x45, 0x4e, 0x43, 0x52, 0x59, 0x50,\n 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x43, 0x4f, 0x4d, 0x4d, 0x49, 0x54, 0x4d, 0x45, 0x4e, 0x54, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\n];\n\n/// WRAPPERS\n\npub fn compute_commitment(inputs: [Field], domain_separator: [u8; 64]) -> Field {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 1])[0]\n}\n\npub fn compute_single_polynomial_commitment<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_single_polynomial_commitment`] with the digit asserts, for a polynomial this circuit\n/// carries no bound for. ct1 commits `u` this way: ct0 range-checks the same `u` to `u_bound` and the\n/// `user_data_encryption` fold asserts the two `u` commitments are equal, so making ct1\'s packing\n/// injective is what forces its `u` to equal ct0\'s \u2014 the bound transfers instead of being repeated.\n/// Produces the same value as the plain version for any input the plain version could legitimately\n/// have committed.\npub fn compute_single_polynomial_commitment_checked<let N: u32, let BIT: u32>(\n polynomial: Polynomial<N>,\n domain_separator: [u8; 64],\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT>([].as_vector(), polynomial);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_multiple_polynomial_commitment<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\npub fn compute_challenge<let L: u32>(inputs: [Field], domain_separator: [u8; 64]) -> [Field] {\n compute_safe(domain_separator, inputs, [0x80000000 | inputs.len(), 2 * L])\n}\n\npub fn single_polynomial_payload<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten::<_, _, BIT_POLY>(payload, inputs)\n}\n\npub fn single_polynomial_payload_checked<let N: u32, let BIT_POLY: u32>(\n payload: [Field],\n input: Polynomial<N>,\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, [input])\n}\n\npub fn multiple_polynomial_payload_checked<let N: u32, let L: u32, let BIT_POLY: u32>(\n payload: [Field],\n inputs: [Polynomial<N>; L],\n) -> [Field] {\n flatten_checked::<_, _, BIT_POLY>(payload, inputs)\n}\n\n/// COMMITMENTS\n\npub fn compute_dkg_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let mut payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n payload = multiple_polynomial_payload::<N, L, BIT_PK>(payload, pk1);\n\n compute_commitment(payload, DS_PK)\n}\n\npub fn compute_threshold_pk_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\n/// [`compute_multiple_polynomial_commitment`] for a circuit that **opens** this commitment.\npub fn compute_multiple_polynomial_commitment_checked<let N: u32, let L: u32, let BIT: u32>(\n polynomials: [Polynomial<N>; L],\n domain_separator: [u8; 64],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT>([].as_vector(), polynomials);\n compute_commitment(payload, domain_separator)\n}\n\n/// [`compute_threshold_pk_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C5). Asserts each packed digit fits its slot, which makes the opening unique and so\n/// forces the opened `pk0` to equal the `pk0` C1 committed. Produces the same value as the plain\n/// helper, so C1 needs no change.\npub fn compute_threshold_pk_commitment_checked<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_PK>([].as_vector(), pk0);\n compute_commitment(payload, DS_PK_GENERATION)\n}\n\npub fn compute_share_computation_sk_commitment<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\n/// [`compute_share_computation_sk_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2a). C1 creates it and bounds `sk` to the trinary range, so making the opening\n/// unique forces the witness to equal that `sk`.\npub fn compute_share_computation_sk_commitment_checked<let N: u32, let BIT_SK: u32>(\n sk: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_SK>([].as_vector(), sk);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_computation_e_sm_commitment<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_share_encryption_commitment_from_message<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\n/// [`compute_share_encryption_commitment_from_message`] for a circuit that **opens** this\n/// commitment rather than creating it (C4). Asserts each packed digit fits its slot, forcing the\n/// opened share to equal the share C2 committed. Same value as the plain helper, so C2 and C3 need\n/// no change.\npub fn compute_share_encryption_commitment_from_message_checked<let N: u32, let BIT_MSG: u32>(\n message: Polynomial<N>,\n) -> Field {\n let payload = single_polynomial_payload_checked::<N, BIT_MSG>([].as_vector(), message);\n compute_commitment(payload, DS_SHARE_ENCRYPTION)\n}\n\npub fn compute_aggregated_shares_commitment<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// Commitment to a threshold decryption share: all CRT limbs, first `K` coefficients per limb\n/// (same layout as `Polynomial<K>` in decrypted_shares_aggregation).\n///\n/// `NATIVE_BIT_WIDTH` must cover native coefficients in \\([0, q_l)\\) per limb (not centered `d` bounds).\npub fn compute_threshold_decryption_share_commitment<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload =\n multiple_polynomial_payload::<K, L, NATIVE_BIT_WIDTH>([].as_vector(), d_share_limbs);\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_threshold_decryption_share_commitment`] for a circuit that **opens** this commitment\n/// rather than creating it (C7). C6 creates it and pins each coefficient to a native residue in\n/// \\([0, q)\\) via `verify_d_native_trunc_binding`, so asserting the digits here makes the opening\n/// unique and forces the opened share to equal the one C6 committed. Produces the same value as the\n/// plain version for any input the plain version could legitimately have committed.\npub fn compute_threshold_decryption_share_commitment_checked<let K: u32, let L: u32, let NATIVE_BIT_WIDTH: u32>(\n d_share_limbs: [Polynomial<K>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<K, L, NATIVE_BIT_WIDTH>(\n [].as_vector(),\n d_share_limbs,\n );\n compute_commitment(payload, DS_THRESHOLD_DECRYPTION_SHARE)\n}\n\n/// [`compute_share_computation_e_sm_commitment`] for a circuit that **opens** this commitment rather\n/// than creating it (C2b). C1 creates it and bounds each `e_sm` limb to a centered residue.\npub fn compute_share_computation_e_sm_commitment_checked<let N: u32, let L: u32, let BIT_E_SM: u32>(\n e_sm: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_E_SM>([].as_vector(), e_sm);\n compute_commitment(payload, DS_SHARE_COMPUTATION)\n}\n\npub fn compute_pk_aggregation_commitment<let N: u32, let L: u32, let BIT_PK: u32>(\n pk0: [Polynomial<N>; L],\n pk1: [Polynomial<N>; L],\n) -> Field {\n let commit_pk0 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk0, DS_PK_AGGREGATION);\n let commit_pk1 = compute_multiple_polynomial_commitment::<N, L, BIT_PK>(pk1, DS_PK_AGGREGATION);\n\n let inputs = [commit_pk0, commit_pk1].as_vector();\n\n compute_commitment(inputs, DS_PK_AGGREGATION)\n}\n\npub fn compute_recursive_aggregation_commitment(payload: [Field]) -> Field {\n compute_commitment(payload, DS_RECURSIVE_AGGREGATION)\n}\n\npub fn compute_vk_hash(vk_hashes: [Field]) -> Field {\n compute_commitment(vk_hashes, DS_VK_HASH)\n}\n\n/// [`compute_aggregated_shares_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). C4 creates it after `normalize_aggregated` has reduced and centered the\n/// aggregate, so making the opening unique forces the witness to equal that canonical value.\npub fn compute_aggregated_shares_commitment_checked<let N: u32, let L: u32, let BIT_MSG: u32>(\n agg_shares: [Polynomial<N>; L],\n) -> Field {\n let payload = multiple_polynomial_payload_checked::<N, L, BIT_MSG>([].as_vector(), agg_shares);\n compute_commitment(payload, DS_AGGREGATED_SHARES)\n}\n\n/// [`compute_ciphertext_commitment`] for a circuit that **opens** this commitment rather than\n/// creating it (C6). No upstream circuit bounds the ciphertext limbs, so this buys injectivity\n/// rather than canonicality \u2014 which is the property wanted here: it forces C6 to decrypt exactly\n/// the ciphertext that was committed, whatever its representation.\npub fn compute_ciphertext_commitment_checked<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 =\n compute_multiple_polynomial_commitment_checked::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\npub fn compute_ciphertext_commitment<let N: u32, let L: u32, let BIT_CT: u32>(\n ct0: [Polynomial<N>; L],\n ct1: [Polynomial<N>; L],\n) -> Field {\n let commit_ct0 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct0, DS_CIPHERTEXT);\n let commit_ct1 = compute_multiple_polynomial_commitment::<N, L, BIT_CT>(ct1, DS_CIPHERTEXT);\n\n let inputs = [commit_ct0, commit_ct1].as_vector();\n\n compute_commitment(inputs, DS_CIPHERTEXT)\n}\n\n/// COMMITMENTS FOR CHALLENGES\n\npub fn compute_threshold_pk_challenge(payload: [Field]) -> Field {\n compute_commitment(payload, DS_CLG_PK_GENERATION)\n}\n\npub fn compute_share_encryption_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_SHARE_ENCRYPTION)\n}\n\npub fn compute_threshold_share_decryption_challenge<let L: u32>(payload: [Field]) -> Field {\n compute_challenge::<L>(payload, DS_CLG_SHARE_DECRYPTION)[0]\n}\n\npub fn compute_user_data_encryption_ct0_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n\npub fn compute_user_data_encryption_ct1_challenge<let L: u32>(payload: [Field]) -> [Field] {\n compute_challenge::<L>(payload, DS_CLG_USER_DATA_ENCRYPTION)\n}\n', path: "interfold/circuits/lib/src/math/commitments.nr", function_locations: [{ start: 7784, name: "compute_commitment" }, { start: 8012, name: "compute_single_polynomial_commitment" }, { start: 8827, name: "compute_single_polynomial_commitment_checked" }, { start: 9138, name: "compute_multiple_polynomial_commitment" }, { start: 9375, name: "compute_challenge" }, { start: 9585, name: "single_polynomial_payload" }, { start: 9784, name: "multiple_polynomial_payload" }, { start: 9970, name: "single_polynomial_payload_checked" }, { start: 10185, name: "multiple_polynomial_payload_checked" }, { start: 10406, name: "compute_dkg_pk_commitment" }, { start: 10733, name: "compute_threshold_pk_commitment" }, { start: 11138, name: "compute_multiple_polynomial_commitment_checked" }, { start: 11750, name: "compute_threshold_pk_commitment_checked" }, { start: 12008, name: "compute_share_computation_sk_commitment" }, { start: 12516, name: "compute_share_computation_sk_commitment_checked" }, { start: 12795, name: "compute_share_computation_e_sm_commitment" }, { start: 13067, name: "compute_share_encryption_commitment_from_message" }, { start: 13647, name: "compute_share_encryption_commitment_from_message_checked" }, { start: 13931, name: "compute_aggregated_shares_commitment" }, { start: 14512, name: "compute_threshold_decryption_share_commitment" }, { start: 15336, name: "compute_threshold_decryption_share_commitment_checked" }, { start: 15876, name: "compute_share_computation_e_sm_commitment_checked" }, { start: 16182, name: "compute_pk_aggregation_commitment" }, { start: 16571, name: "compute_recursive_aggregation_commitment" }, { start: 16686, name: "compute_vk_hash" }, { start: 17169, name: "compute_aggregated_shares_commitment_checked" }, { start: 17843, name: "compute_ciphertext_commitment_checked" }, { start: 18325, name: "compute_ciphertext_commitment" }, { start: 18724, name: "compute_threshold_pk_challenge" }, { start: 18866, name: "compute_share_encryption_challenge" }, { start: 19023, name: "compute_threshold_share_decryption_challenge" }, { start: 19183, name: "compute_user_data_encryption_ct0_challenge" }, { start: 19344, name: "compute_user_data_encryption_ct1_challenge" }] }, "88": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\n//! Helper functions for circuit construction and cryptographic operations.\nuse crate::math::polynomial::Polynomial;\nuse crate::math::safe::SafeSponge;\n\n/// Compute hex-aligned packing parameters for a given `BIT`.\n///\n/// # Purpose\n/// Returns `(nibble_bits, group)` for use by pack/flatten so layout stays consistent.\n/// - `nibble_bits`: ceil (`BIT`) to the next multiple of 4 (nibble alignment).\n/// - Examples: `BIT = 7 -> 8`, `BIT = 8 -> 8`, `BIT = 9 -> 12`, `BIT = 10 -> 12`, `BIT = 11 -> 12`,\n/// `BIT=16 -> 16`, `BIT = 17 -> 20`.\n/// - `group`: max number of encoded limbs that fit in one BN254 field element,\n/// when each limb uses an extra 4 bits (see below).\n///\n/// # Rationale\n/// - We align to nibbles so powers of two are hex-friendly and deterministic.\n/// - We reserve one extra nibble (4 bits) per stored value to lift signed\n/// coefficients into the non-negative range (e.g., store `v + 2^nibble_bits`),\n/// which implies a radix of `2^(nibble_bits + 4)`.\n///\n/// # Safety\n/// - Asserts `nibble_bits + 4 <= 254` to avoid mod-p wrap on BN254.\n/// - Ensures at least one limb fits: `group >= 1`.\nfn packing_layout<let BIT: u32>() -> (u32, u32) {\n // Ceil BIT up to the next multiple of 4 (nibble alignment).\n let nibble_bits = ((BIT + 3) / 4) * 4;\n\n // Each stored limb uses an extra nibble because negative coefficients\n // will be shifted to positive, so radix = 2^(nibble_bits+4).\n assert(nibble_bits + 4 <= 254);\n\n // Maximum limbs that fit in one BN254 element without wrap.\n let group = 254 / (nibble_bits + 4);\n // `group == 1` packs one value per carrier: it saves no sponge absorptions at all while still\n // charging the range checks that make packing injective, so it is always a loss. Measured at\n // BIT=143: +82% gates against absorbing directly. Reject it rather than pay for nothing.\n assert(group >= 2);\n (nibble_bits, group)\n}\n\n/// Like [`pack`], but asserts every digit fits its slot.\n///\n/// ## Why\n/// `pack` builds each carrier as a base-`radix` number, `acc = acc * radix + (v + base)`. That\n/// representation is unique only while every digit stays below `radix`. An unbounded value can\n/// overflow its slot and cancel against the next, so one commitment gains a second opening and a\n/// prover can choose which coefficients it opens to.\n///\n/// `digit < radix` is exactly `digit.assert_max_bit_size::<nibble_bits + 4>()`, and because\n/// `assert_max_bit_size` also forces `digit >= 0`, a single assert gives the whole condition.\n///\n/// ## When to use it\n/// Use this where a circuit **opens** a commitment it did not create. The creating circuit's own\n/// range checks already keep its digits in slot, so asserting the same here forces the opened\n/// coefficients to equal the committed ones \u2014 injectivity transfers the upstream bound without\n/// repeating it. One assert costs about half a two-sided `range_check_2bounds`.\n///\n/// It does **not** replace a bound the protocol requires in its own right, and it gives injectivity,\n/// not canonicality: it pins the opening, not a unique representative modulo `q`. A value that no\n/// upstream circuit bounded still needs its own check (see C1 `pk0` and C5 `pk0_agg`).\n///\n/// ## Compatibility\n/// Adding asserts does not change the packed value, so a commitment created with [`pack`] and\n/// opened with `pack_checked` agree. Adoption is per circuit and needs no commitment change.\npub fn pack_checked<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field);\n let radix = 2.pow_32((nibble_bits + 4) as Field);\n\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n for chunk in 0..num_chunks {\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n let digit = v + base;\n // digit < radix = 2^(nibble_bits + 4): the injectivity condition.\n digit.assert_max_bit_size::<((BIT + 3) / 4) * 4 + 4>();\n acc = acc * radix + digit;\n }\n\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Like [`flatten`], but packs with [`pack_checked`]. Use where a circuit opens a commitment it did\n/// not create.\npub fn flatten_checked<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n let packed = pack_checked::<A, BIT>(poly[j].coefficients);\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n inputs\n}\n\n/// Flatten `L` polynomials into a single linear stream of packed `Field` carriers.\n///\n/// ## What this does\n/// - For each CRT limb `j` in `0..L`, it packs the coefficients of `poly[j]`\n/// with `pack::<A, BIT>` and appends all resulting carriers to `inputs`.\n/// - The packing layout (nibble-aligned width and `group` size) is taken from\n/// `packing_layout::<BIT>()` and must match what `pack` uses.\n///\n/// ## Determinism & order\n/// - Preserves a stable order: iterate `j = 0..L`, then for each `j` append\n/// carriers in ascending chunk index `i = 0..num_chunks`.\n/// - This ensures transcripts remain deterministic across runs.\n///\n/// ## Generics\n/// - `A`: polynomial degree (number of coefficients per polynomial).\n/// - `L`: number of CRT bases (polynomials).\n/// - `BIT`: per-coefficient bit bound used by the packing layout (compile-time).\n///\n/// ## Returns\n/// - The same `inputs` vector, extended with all carriers in deterministic order.\npub fn flatten<let A: u32, let L: u32, let BIT: u32>(\n mut inputs: [Field],\n poly: [Polynomial<A>; L],\n) -> [Field] {\n for j in 0..L {\n // Pack its A coefficients into `num_chunks` carriers using the same BIT layout.\n let packed = pack::<A, BIT>(poly[j].coefficients);\n\n // Append carriers in-order to `inputs` to keep a stable transcript layout.\n for i in 0..packed.len() {\n inputs = inputs.push_back(packed[i]);\n }\n }\n\n // Return the extended input stream.\n inputs\n}\n\n/// Pack `A` values into a `[Field]` vector of carriers using the shared hex-aligned layout.\n///\n/// ## What this does\n/// - Computes `(nibble_bits, group)` via `packing_layout::<BIT>()`.\n/// - Encodes each value as a limb `digit = v + 2^nibble_bits` and concatenates\n/// limbs in base `radix = 2^(nibble_bits + 4)` (one extra nibble of headroom).\n/// - Packs up to `group` limbs per carrier (fits within BN254 254-bit capacity).\n/// - Pads the last, partial carrier with `digit = 2^nibble_bits` to keep a stable layout.\n///\n/// ## Determinism & order\n/// - Processes values in increasing index order and emits carriers in chunk order\n/// (`chunk = 0..num_chunks`). Padding is deterministic.\n///\n/// ## Generics\n/// - `A`: number of input values.\n/// - `BIT`: per-value bit bound; rounded up to `nibble_bits` by `packing_layout`.\n///\n/// ## Preconditions / Notes\n/// - Call with the raw coefficients whose magnitudes already satisfy the BIT bound\n/// (as enforced by the upstream range checks); `pack` performs the signed -> unsigned\n/// shift internally via `v + base`.\n/// - `group >= 1` is enforced by `packing_layout::<BIT>()`.\n/// - Padding with `digit = 2^nibble_bits` encodes `zero limb` consistently.\n///\n/// ## Returns\n/// - A `[Field]` vector where each element is a concatenation of up to `group` limbs,\n/// suitable for hashing or transcript I/O.\npub fn pack<let A: u32, let BIT: u32>(values: [Field; A]) -> [Field] {\n // Layout parameters: nibble-aligned width and limbs-per-carrier group size.\n let (nibble_bits, group) = packing_layout::<BIT>();\n\n let base = 2.pow_32(nibble_bits as Field); // 2^nibble_bits\n let radix = 2.pow_32((nibble_bits + 4) as Field); // 2^(nibble_bits + 4)\n\n // Number of chunks to emit: ceil(A / group).\n let num_chunks = (A + group - 1) / group;\n let mut out: [Field] = [].as_vector();\n\n // Process in fixed-size chunks of `group` limbs.\n for chunk in 0..num_chunks {\n // How many real values go into this chunk.\n let remain = A - (chunk * group);\n let take = if remain < group { remain } else { group };\n\n // Build field element accumulator (big-endian concatenation in `radix`).\n let mut acc = 0;\n for i in 0..take {\n let v = values[chunk * group + i];\n acc = acc * radix + (v + base);\n }\n\n // Pad remaining limb slots with the canonical zero-limb `digit = base`.\n for _ in 0..(group - take) {\n acc = acc * radix + base;\n }\n\n out = out.push_back(acc);\n }\n out\n}\n\n/// Computes a cryptographic hash using the SAFE (Sponge API for Field Elements) protocol.\n///\n/// This is a convenience wrapper around the SAFE sponge API that handles the full\n/// lifecycle: initialization, absorption, squeezing, and finalization. It's designed\n/// for use in Fiat-Shamir challenge generation and commitment schemes within zero-knowledge circuits.\n///\n/// # Arguments\n/// * `domain_separator` - A 64-byte domain separator used to differentiate between\n/// different protocol instances and prevent cross-protocol attacks.\n/// * `inputs` - Vector of field elements to be absorbed into the sponge.\n/// * `io_pattern` - A 2-element array encoding the I/O pattern:\n/// - `io_pattern[0]`: Encoded ABSORB operation (MSB=1, lower 31 bits = length)\n/// - `io_pattern[1]`: Encoded SQUEEZE operation (MSB=0, lower 31 bits = length)\n///\n/// # Returns\n/// A vector of field elements squeezed from the sponge, with length determined by\n/// the SQUEEZE operation in the IO pattern.\n/// Proves `0 <= v < upper` using two one-sided bit-size checks.\n///\n/// `assert_max_bit_size` is one-sided: it forces a small **non-negative** field element. So bounding\n/// `v` gives `v >= 0`, and bounding `upper - 1 - v` gives `v <= upper - 1`. The pair composes into a\n/// two-sided interval without a comparison operator.\n///\n/// `BIT` must cover `upper`; the caller supplies it from the generated config.\npub fn assert_in_range<let BIT: u32>(v: Field, upper: Field) {\n v.assert_max_bit_size::<BIT>();\n (upper - 1 - v).assert_max_bit_size::<BIT>();\n}\n\npub fn compute_safe(domain_separator: [u8; 64], inputs: [Field], io_pattern: [u32; 2]) -> [Field] {\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(inputs);\n let digests = sponge.squeeze();\n sponge.finish();\n\n digests\n}\n\n#[test]\nfn test_flatten() {\n // Create test polynomials\n let poly1 = Polynomial::new([1, 2, 3]); // degree 2\n let poly2 = Polynomial::new([4, -16, 6]); // degree 2\n let poly3 = Polynomial::new([-7, 8, 9]); // degree 2\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 4>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n assert(result[0] == 0x11121310101010101010101010101010101010101010101010101010101010);\n assert(result[1] == 0x14001610101010101010101010101010101010101010101010101010101010); // -16 became 00 at 0x 14 00 16,\n assert(result[2] == 0x09181910101010101010101010101010101010101010101010101010101010); // -7 became 09 at 0x 09 18 19(16 - 7 = 9)\n}\n\n#[test]\nfn test_flatten_big() {\n // Create test polynomials\n let poly1 = Polynomial::new([\n 1791218451968394,\n 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n 5430119342984413,\n 704811298945172,\n 8901715723925099,\n 21888242871839275222246405745257275088548364400416034343698203098124042812559,\n 21888242871839275222246405745257275088548364400416034343698200215091693880034,\n ]);\n let poly2 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698200314078269634250,\n 21888242871839275222246405745257275088548364400416034343698200967285641915872,\n 2909990636858607,\n 7896103832076587,\n 2078397209533893,\n 21888242871839275222246405745257275088548364400416034343698199792421452734531,\n 614400389245817,\n 8290314119277588,\n ]);\n let poly3 = Polynomial::new([\n 21888242871839275222246405745257275088548364400416034343698201373175279892906,\n 21888242871839275222246405745257275088548364400416034343698201087241869723721,\n 6768789983786188,\n 635797784303388,\n 7610153424227556,\n 4633893206538324,\n 2016269760615332,\n 21888242871839275222246405745257275088548364400416034343698201007080554428142,\n ]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 54>(inputs, polynomials);\n\n // Verify the flattened coefficients are in the correct positions\n // Every value shifted 1 nibble incase of negative integers\n\n // For the first index of result operation goes like this,\n\n // First four index of poly1\n // 1791218451968394,\n // 21888242871839275222246405745257275088548364400416034343698198265248580087864,\n // 21888242871839275222246405745257275088548364400416034343698200542108324633466,\n // 5430119342984413,\n\n // base + 1791218451968394 = 0x1065d1a8b8b718a\n // base - 5921327228407753 = 0xeaf69591f3b037 (negative coefficient shifted)\n // base - 3644467483862151 = 0xf30d604a3a9b79 (negative coefficient shifted)\n // base + 5430119342984413 = 0x1134aaa2e86ccdd\n assert(result[0] == 0x1065d1a8b8b718a0eaf69591f3b0370f30d604a3a9b791134aaa2e86ccdd);\n assert(result[1] == 0x1028105ab1b789411fa010339db66b0fc220f1326bc8e0f1e3f4cc1e02e1);\n assert(result[2] == 0x0f23dfbe7cd76c90f4901299312ddf10a569efe35acef11c0d76f005412b);\n assert(result[3] == 0x107624a8f605dc50f0638a368960421022ecb3cf36b7911d73ff2c27ec14);\n assert(result[4] == 0x0f6013a24e1b9a90f4fd2c158a08481180c2dba8af4cc10242413515171c);\n assert(result[5] == 0x11b0964eb898ce411076805680b85410729c962da53a40f4b44412d0f6ed);\n}\n\n#[test]\nfn test_flatten_small() {\n // Create test polynomials\n let poly1 = Polynomial::new([712345, 104857, 999999, 500001, 123, 654321, 77]);\n let poly2 = Polynomial::new([1, 524287, 888888, 23456, 34567, 765432, 0]);\n let poly3 = Polynomial::new([444444, 333333, 222222, 111111, 987654, 246810, 13579]);\n\n let polynomials = [poly1, poly2, poly3];\n\n // Initialize target array with zeros\n let inputs: [Field] = [].as_vector();\n\n // Flatten the polynomials\n let result = flatten::<_, _, 20>(inputs, polynomials);\n\n assert(result[0] == 0x1ade991199991f423f17a12110007b19fbf110004d100000100000100000);\n assert(result[1] == 0x10000117ffff1d9038105ba01087071badf8100000100000100000100000);\n assert(result[2] == 0x16c81c15161513640e11b2071f120613c41a10350b100000100000100000);\n}\n\n#[test]\nfn test_safe_hashing_with_safe_helper() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let digests1 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests1.len() == 1);\n assert(digests1[0] != 0);\n\n // Test determinism\n let digests2 = compute_safe(domain_separator, elements, io_pattern);\n\n assert(digests2.len() == 1);\n assert(digests2[0] != 0);\n assert(digests2[0] == digests1[0]);\n}\n\n#[test]\nfn test_pack() {\n // Test pack function directly with small values\n let values = [1, 2, 3, 4];\n let packed = pack::<4, 4>(values);\n\n // With BIT=4, nibble_bits=4, group should be floor(254/(4+4)) = 31\n // So all 4 values should fit in one carrier\n assert(packed.len() >= 1);\n\n // Test with negative values\n let values_neg = [-1, 2, -3, 4];\n let packed_neg = pack::<4, 4>(values_neg);\n assert(packed_neg.len() >= 1);\n}\n\n#[test]\nfn test_pack_single_value() {\n // Test packing a single value\n let values = [42];\n let packed = pack::<1, 8>(values);\n assert(packed.len() == 1);\n assert(packed[0] != 0);\n}\n\n#[test]\nfn test_pack_determinism() {\n // Test that packing is deterministic\n let values = [10, 20, 30];\n let packed1 = pack::<3, 8>(values);\n let packed2 = pack::<3, 8>(values);\n\n assert(packed1.len() == packed2.len());\n for i in 0..packed1.len() {\n assert(packed1[i] == packed2[i]);\n }\n}\n\n/// `pack_checked` must agree with `pack` for in-slot values. The two carry duplicate layout\n/// arithmetic, so if one is changed without the other, a commitment created by a circuit on `pack`\n/// stops matching one opened by a circuit on `pack_checked`. This pins that.\n#[test]\nfn test_pack_checked_matches_pack() {\n // Mixed signs, and values at the edge of the centred window for BIT = 35 (slot = 2^40).\n let vals: [Field; 7] = [0, 1, -1, 34359701504, -34359701504, 12345, -6789];\n let plain = pack::<7, 35>(vals);\n let checked = pack_checked::<7, 35>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n\n/// Same, at a width whose chunking leaves a partial final carrier (BIT = 57 -> group 3, 7 values).\n#[test]\nfn test_pack_checked_matches_pack_partial_chunk() {\n let vals: [Field; 7] = [5, -5, 72057594049265664, -72057594049265664, 1, 0, -1];\n let plain = pack::<7, 57>(vals);\n let checked = pack_checked::<7, 57>(vals);\n assert(plain.len() == checked.len());\n for i in 0..plain.len() {\n assert(plain[i] == checked[i]);\n }\n}\n", path: "interfold/circuits/lib/src/math/helpers.nr", function_locations: [{ start: 1374, name: "packing_layout" }, { start: 3703, name: "pack_checked" }, { start: 4808, name: "flatten_checked" }, { start: 6096, name: "flatten" }, { start: 7946, name: "pack" }, { start: 10581, name: "assert_in_range" }, { start: 10770, name: "compute_safe" }, { start: 10968, name: "test_flatten" }, { start: 11911, name: "test_flatten_big" }, { start: 14812, name: "test_flatten_small" }, { start: 15639, name: "test_safe_hashing_with_safe_helper" }, { start: 16485, name: "test_pack" }, { start: 16955, name: "test_pack_single_value" }, { start: 17151, name: "test_pack_determinism" }, { start: 17749, name: "test_pack_checked_matches_pack" }, { start: 18287, name: "test_pack_checked_matches_pack_partial_chunk" }] }, "95": { source: "// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse super::modulo::U128::ModU128;\n\n/// Polynomial structure representing a polynomial of degree N-1.\n///\n/// A polynomial P(X) = a_{N-1} * X^{N-1} + a_{N-2} * X^{N-2} + ... + a_1 * X + a_0\n/// is represented as an array of coefficients where coefficients[0] = a_{N-1} (highest degree)\n/// and coefficients[N-1] = a_0 (constant term).\npub struct Polynomial<let N: u32> {\n /// Array of polynomial coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1} (highest degree term)\n /// coefficients[N-1] = constant term (degree 0)\n pub coefficients: [Field; N],\n}\n\nimpl<let N: u32> Polynomial<N> {\n /// Creates a new polynomial from an array of coefficients.\n ///\n /// # Arguments\n /// * `coefficients` - Array of N coefficients in descending degree order\n /// coefficients[0] = coefficient of X^{N-1}\n /// coefficients[N-1] = constant term\n ///\n /// # Returns\n /// A new Polynomial instance with the specified coefficients\n pub fn new(coefficients: [Field; N]) -> Self {\n Polynomial { coefficients }\n }\n\n /// Adds two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to add to the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients added.\n pub fn add(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] + other.coefficients[i];\n }\n\n result\n }\n\n /// Subtracts two polynomials.\n ///\n /// # Arguments\n /// * `other` - The polynomial to subtract from the current polynomial.\n ///\n /// # Returns\n /// A new polynomial with the coefficients subtracted.\n pub fn sub(self, other: Self) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] - other.coefficients[i];\n }\n\n result\n }\n\n /// Multiplies a polynomial by a scalar.\n ///\n /// # Arguments\n /// * `scalar` - The scalar to multiply the polynomial by.\n ///\n /// # Returns\n /// A new polynomial with the coefficients multiplied by the scalar.\n pub fn mul_scalar(self, scalar: Field) -> Self {\n let mut result = Self::new([0; N]);\n\n for i in 0..N {\n result.coefficients[i] = self.coefficients[i] * scalar;\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point using Horner's method.\n ///\n /// Horner's method computes P(x) = a_{N-1} * x^{N-1} + ... + a_1 * x + a_0\n /// as ((...((a_{N-1} * x + a_{N-2}) * x + a_{N-3}) * x + ...) * x + a_0)\n /// This approach require n multiplications and n additions to evaluate the polynomial.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial.\n ///\n /// # Returns\n /// The value of the polynomial at point x: P(x).\n /// Inner product of the coefficients with `k`, in the same index order.\n ///\n /// Paired with [`negacyclic_kernel`] this evaluates a product modulo `X^N + 1` without the\n /// product itself entering the witness.\n pub fn dot(self, k: [Field; N]) -> Field {\n let mut out: Field = 0;\n for j in 0..N {\n out += self.coefficients[j] * k[j];\n }\n out\n }\n\n pub fn eval(self, x: Field) -> Field {\n let mut result = self.coefficients[0];\n\n for i in 1..self.coefficients.len() {\n result = result * x + self.coefficients[i];\n }\n\n result\n }\n\n /// Evaluates the polynomial at a given point with modular reduction.\n ///\n /// This function computes `P(x) mod q` using Horner's method with intermediate\n /// modular reductions to prevent overflow. The result is guaranteed to be in\n /// the range `[0, q)`.\n ///\n /// The function performs modular reduction after each multiplication and addition\n /// to ensure the accumulator always remains in the range `[0, q)`, preventing\n /// any potential overflow issues.\n ///\n /// # Arguments\n /// * `x` - The point at which to evaluate the polynomial\n /// * `q` - The modular arithmetic context containing the modulus\n ///\n /// # Returns\n /// The value `P(x) mod q` in the range `[0, q)`\n pub fn eval_mod(self, x: Field, q: ModU128) -> Field {\n let mut acc = self.coefficients[0];\n let len = self.coefficients.len();\n\n for i in 1..len {\n acc = q.mul_mod(acc, x);\n acc = q.add(acc, self.coefficients[i]);\n }\n\n acc\n }\n\n /// Performs range checking on polynomial coefficients using asymmetric bounds.\n ///\n /// This function constrains all polynomial coefficients to be in the range [-lower_bound, upper_bound],\n /// where `lower_bound` is a non-negative magnitude.\n /// It uses a shifting technique to handle negative numbers efficiently:\n /// 1. Shifts each coefficient by adding `lower_bound`: c' = c + lower_bound\n /// 2. Checks that shifted coefficients are in [0, upper_bound + lower_bound] using bit-size assertions\n /// 3. This ensures original coefficients are in [-lower_bound, upper_bound]\n ///\n /// The function uses two bit-size checks per coefficient to ensure the value is within bounds:\n /// - `shifted_coefficient.assert_max_bit_size::<BIT + 1>()` ensures c' >= 0\n /// - `(range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>()` ensures c' <= range_size\n ///\n /// # Arguments\n /// * `upper_bound` - The upper bound for coefficient range checking\n /// * `lower_bound` - Non-negative magnitude of the negative bound\n /// Coefficients must satisfy: -lower_bound <= c <= upper_bound\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length of the total range `upper_bound + lower_bound`\n /// (choose `BIT` so `upper_bound + lower_bound < 2^BIT`). Since all checked\n /// values lie in `[0, upper_bound + lower_bound]`, they cannot exceed `BIT + 1` bits.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the specified bounds.\n pub fn range_check_2bounds<let BIT: u32>(self, upper_bound: Field, lower_bound: Field) {\n let range_size = lower_bound + upper_bound;\n\n for i in 0..self.coefficients.len() {\n let shifted_coefficient = self.coefficients[i] + lower_bound;\n\n shifted_coefficient.assert_max_bit_size::<BIT + 1>();\n (range_size - shifted_coefficient).assert_max_bit_size::<BIT + 1>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, upper_bound).\n ///\n /// This function constrains all polynomial coefficients to be non-negative and\n /// strictly less than `upper_bound`. It uses bit-size assertions to verify that\n /// coefficients are in the valid range.\n ///\n /// The function performs two checks per coefficient:\n /// 1. `coeff.assert_max_bit_size::<BIT>()` ensures `coeff >= 0` and `coeff < 2^BIT`\n /// 2. `(upper_bound - 1 - coeff).assert_max_bit_size::<BIT>()` ensures `coeff < upper_bound`\n ///\n /// # Arguments\n /// * `upper_bound` - The exclusive upper bound for coefficient range checking.\n /// Coefficients must satisfy: `0 <= c < upper_bound`\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Must satisfy `upper_bound <= 2^BIT` for\n /// the range check to work correctly.\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, upper_bound)`.\n pub fn range_check_standard<let BIT: u32>(self, upper_bound: Field) {\n for i in 0..self.coefficients.len() {\n let coeff = self.coefficients[i];\n // Check coeff >= 0 and coeff < 2^BIT\n coeff.assert_max_bit_size::<BIT>();\n // Check coeff <= upper_bound - 1 (i.e., coeff < upper_bound)\n (upper_bound - 1 - coeff).assert_max_bit_size::<BIT>();\n }\n }\n\n /// Performs range checking on polynomial coefficients for the range [0, 2^BIT).\n ///\n /// This is a specialized range check for coefficients that must be non-negative\n /// and less than a power of two. It's more efficient than `range_check_standard`\n /// when the upper bound is exactly `2^BIT` because it only needs a single\n /// bit-size assertion per coefficient.\n ///\n /// The function verifies that each coefficient satisfies:\n /// - `coeff >= 0` (implicit from bit-size check)\n /// - `coeff < 2^BIT` (enforced by `assert_max_bit_size::<BIT>()`)\n ///\n /// # Generic Parameters\n /// * `BIT` - The bit-length parameter. Coefficients must satisfy: `0 <= c < 2^BIT`\n ///\n /// # Panics\n /// This function will cause the circuit to fail if any coefficient is outside\n /// the range `[0, 2^BIT)`.\n pub fn range_check_power_of_two<let BIT: u32>(self) {\n for i in 0..self.coefficients.len() {\n self.coefficients[i].assert_max_bit_size::<BIT>();\n }\n }\n}\n\n#[test]\nfn test_polynomial_eval_zero() {\n let coeffs = [1, -2, 1]; // x^2 - 2x + 1 = (x-1)^2\n let poly = Polynomial::new(coeffs);\n\n let x = 1; // evaluate at x = 1, should be 0\n let result = poly.eval(x);\n\n assert(result == 0);\n}\n\n/// Evaluation kernel for `u` modulo `X^N + 1`: `out[j]` is `(X^(N-1-j) * u mod X^N + 1)(x)`.\n///\n/// `a.dot(negacyclic_kernel(u, x))` then equals `(a * u mod X^N + 1)(x)` without the prover\n/// supplying the product, so no product witness has to be bound or range-checked.\npub fn negacyclic_kernel<let N: u32>(u: Polynomial<N>, x: Field) -> [Field; N] {\n assert(N > 0);\n let phi = x.pow_32(N as Field) + 1;\n let mut out = [0; N];\n out[N - 1] = u.eval(x);\n for j in 1..N {\n out[N - 1 - j] = x * out[N - j] - phi * u.coefficients[j - 1];\n }\n out\n}\n\n#[test]\nfn test_negacyclic_kernel_matches_reduced_product() {\n let a = Polynomial::new([4, 3, 2, 1]);\n let u = Polynomial::new([-1, 0, 1, -1]);\n\n // Schoolbook product, then reduced by hand with X^4 = -1.\n let mut prod = [0; 7];\n for i in 0..4 {\n for j in 0..4 {\n prod[i + j] += a.coefficients[i] * u.coefficients[j];\n }\n }\n let reduced = Polynomial::new([prod[3], prod[4] - prod[0], prod[5] - prod[1], prod[6] - prod[2]]);\n\n let points: [Field; 4] = [0, 1, 2, 17];\n for j in 0..4 {\n let x = points[j];\n assert(a.dot(negacyclic_kernel(u, x)) == reduced.eval(x));\n }\n}\n\n#[test]\nfn test_polynomial_bounds() {\n let coeffs = [-16, 240, 242];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-240, 242]\n poly.range_check_2bounds::<8>(242, 240);\n}\n\n#[test(should_fail_with = \"assert_max_bit_size\")]\nfn test_polynomial_out_of_bounds_coefficients() {\n let coeffs = [-100];\n let poly = Polynomial::new(coeffs);\n\n // Test double bounds check - constrains to [-98, 99]\n // Should fail because -100 is out of bounds.\n poly.range_check_2bounds::<7>(99, 98);\n}\n\n#[test]\nfn test_polynomial_add() {\n let coeffs1 = [1, 2, 3]; // 1x^2 + 2x + 3\n let coeffs2 = [4, 5, 6]; // 4x^2 + 5x + 6\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.add(poly2);\n\n // Expected: (1+4)x^2 + (2+5)x + (3+6) = 5x^2 + 7x + 9\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 7);\n assert(result.coefficients[2] == 9);\n}\n\n#[test]\nfn test_polynomial_sub() {\n let coeffs1 = [5, 7, 9]; // 5x^2 + 7x + 9\n let coeffs2 = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly1 = Polynomial::new(coeffs1);\n let poly2 = Polynomial::new(coeffs2);\n\n let result = poly1.sub(poly2);\n\n // Expected: (5-1)x^2 + (7-2)x + (9-3) = 4x^2 + 5x + 6\n assert(result.coefficients[0] == 4);\n assert(result.coefficients[1] == 5);\n assert(result.coefficients[2] == 6);\n}\n\n#[test]\nfn test_polynomial_mul_scalar() {\n let coeffs = [1, 2, 3]; // 1x^2 + 2x + 3\n let poly = Polynomial::new(coeffs);\n let scalar = 5;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 5x^2 + 10x + 15\n assert(result.coefficients[0] == 5);\n assert(result.coefficients[1] == 10);\n assert(result.coefficients[2] == 15);\n}\n\n#[test]\nfn test_polynomial_mul_scalar_zero() {\n let coeffs = [1, 2, 3];\n let poly = Polynomial::new(coeffs);\n let scalar = 0;\n\n let result = poly.mul_scalar(scalar);\n\n // Expected: 0x^2 + 0x + 0 = 0\n assert(result.coefficients[0] == 0);\n assert(result.coefficients[1] == 0);\n assert(result.coefficients[2] == 0);\n}\n\n#[test]\nfn test_eval_mod_simple() {\n // Test without initial reduction - simple case\n // p(x) = x + 1 at x=5od 7\n // Expected: (5 + 1) mod 7 = 6\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 1]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 6);\n\n // Test: p(x) = 2x + 3 at x=5od 7\n // Expected: (10 + 3) mod 7 = 13 mod 7 = 6\n let poly2 = Polynomial::new([2, 3]);\n let result2 = poly2.eval_mod(5, q);\n assert(result2 == 6);\n}\n\n#[test]\nfn test_eval_mod() {\n // Test 1: Simple polynomial x^2 + 2x + 3 at x=5od 7\n // Expected: (25 + 10 + 3) mod 7 = 38 mod 7 = 3\n let q = ModU128::new(7);\n\n let poly1 = Polynomial::new([1, 2, 3]);\n let result1 = poly1.eval_mod(5, q);\n assert(result1 == 3);\n\n // Test 2: Higher degree polynomialod small prime\n // p(x) = x^3 + x^2 + x + 1 at x=2od 11\n // Expected: (8 + 4 + 2 + 1) mod 11 = 15 mod 11 = 4\n let q = ModU128::new(11);\n\n let poly2 = Polynomial::new([1, 1, 1, 1]);\n let result2 = poly2.eval_mod(2, q);\n assert(result2 == 4);\n\n // Test 3: Polynomial with larger coefficients\n // p(x) = 100x^2 + 50x + 25 at x=10od 73\n // Expected: (10000 + 500 + 25) mod 73 = 10525 mod 73 = 13\n let q = ModU128::new(73);\n\n let poly3 = Polynomial::new([100, 50, 25]);\n let result3 = poly3.eval_mod(10, q);\n assert(result3 == 13);\n\n // Test 4: Result should be less than modulus\n let poly4 = Polynomial::new([5, 3, 7]);\n let q = ModU128::new(17);\n let result4 = poly4.eval_mod(4, q);\n assert(result4 as u128 < q.get_mod_field() as u128);\n\n // Test 5: Compare with regular eval for small values\n let poly5 = Polynomial::new([1, 2, 1]);\n let x = 3;\n let q = ModU128::new(1000);\n let result5 = poly5.eval_mod(x, q);\n let expected5 = poly5.eval(x);\n assert(result5 == expected5);\n\n // Test 6: Zero polynomial\n let poly6 = Polynomial::new([0, 0, 0]);\n let q = ModU128::new(13);\n let result6 = poly6.eval_mod(100, q);\n assert(result6 == 0);\n}\n\n#[test]\nfn test_large_party_ids_scenario() {\n // Simulating party IDs in range [1, 100]\n let party_id_1 = 42;\n let party_id_2 = 73;\n let m = ModU128::new(288230376151711717); // ~58 bits\n\n // Operations that would be used in Lagrange coefficients\n let product = m.mul_mod(party_id_1, party_id_2);\n let diff = m.sub(party_id_2, party_id_1);\n\n assert(product == 3066);\n assert(diff == 31);\n}\n\n#[test]\nfn test_eval_vs_eval_mod() {\n // Compare eval and eval_mod for small values where no reduction should occur\n let poly = Polynomial::new([1, 2, 3]);\n let x = 2;\n let q = ModU128::new(1000); // Large enough that no reduction happens\n\n let result_normal = poly.eval(x);\n let result_mod = poly.eval_mod(x, q);\n\n // They should be equal: (1)*2 + 2)*2 + 3 = (2+2)*2 + 3 = 4*2 + 3 = 11\n assert(result_normal == 11);\n assert(result_mod == 11);\n}\n", path: "interfold/circuits/lib/src/math/polynomial.nr", function_locations: [{ start: 1261, name: "Polynomial<N>::new" }, { start: 1555, name: "Polynomial<N>::add" }, { start: 2008, name: "Polynomial<N>::sub" }, { start: 2481, name: "Polynomial<N>::mul_scalar" }, { start: 3426, name: "Polynomial<N>::dot" }, { start: 3602, name: "Polynomial<N>::eval" }, { start: 4576, name: "Polynomial<N>::eval_mod" }, { start: 6506, name: "Polynomial<N>::range_check_2bounds" }, { start: 7992, name: "Polynomial<N>::range_check_standard" }, { start: 9247, name: "Polynomial<N>::range_check_power_of_two" }, { start: 9416, name: "test_polynomial_eval_zero" }, { start: 9976, name: "negacyclic_kernel" }, { start: 10259, name: "test_negacyclic_kernel_matches_reduced_product" }, { start: 10873, name: "test_polynomial_bounds" }, { start: 11156, name: "test_polynomial_out_of_bounds_coefficients" }, { start: 11411, name: "test_polynomial_add" }, { start: 11844, name: "test_polynomial_sub" }, { start: 12284, name: "test_polynomial_mul_scalar" }, { start: 12641, name: "test_polynomial_mul_scalar_zero" }, { start: 12970, name: "test_eval_mod_simple" }, { start: 13450, name: "test_eval_mod" }, { start: 15008, name: "test_large_party_ids_scenario" }, { start: 15418, name: "test_eval_vs_eval_mod" }] }, "97": { source: '// SPDX-License-Identifier: LGPL-3.0-only\n//\n// This file is provided WITHOUT ANY WARRANTY;\n// without even the implied warranty of MERCHANTABILITY\n// or FITNESS FOR A PARTICULAR PURPOSE.\n\nuse keccak256::keccak256;\nuse poseidon::poseidon2_permutation;\n\n/// SAFE (Sponge API for Field Elements)\n///\n/// This module provides a complete implementation of the SAFE API in Noir as defined in:\n/// "SAFE (Sponge API for Field Elements) - A Toolbox for ZK Hash Applications"\n/// see https://hackmd.io/bHgsH6mMStCVibM_wYvb2w#22-Sponge-state for more details.\n///\n/// SAFE provides a unified interface for cryptographic sponge functions that can be\n/// instantiated with various permutations to create hash functions, MACs, authenticated\n/// encryption schemes, and other cryptographic primitives for ZK proof systems.\n///\n/// This implementation follows the SAFE specification exactly, providing:\n/// - Complete API: START, ABSORB, SQUEEZE, FINISH operations.\n/// - Full security: Domain separation, tag computation, IO pattern validation.\n/// - Poseidon2 integration: Field-friendly permutation for ZK systems.\n/// - Specification compliance: All operations follow SAFE spec 2.4 exactly.\n/// - Natural API design: Variable-length inputs, automatic length detection from IO patterns.\n///\n/// # API Design\n///\n/// The API is designed for natural usage while maintaining type safety:\n/// - `absorb(input: [Field])`: Accepts variable-length arrays, no padding required.\n/// - `squeeze()`: Returns a vector with field element(s).\n/// - IO patterns automatically determine operation lengths for validation.\n\n/// Rate parameter for the sponge construction (number of field elements that can be absorbed per permutation call).\nglobal RATE: u32 = 3;\n\n/// Capacity parameter for the sponge construction (security parameter, typically 1-2 field elements).\nglobal CAPACITY: u32 = 1;\n\n/// Total state size (rate + capacity) in field elements.\nglobal STATE_SIZE: u32 = RATE + CAPACITY;\n\n/// IO Pattern encoding constants (from SAFE spec 2.3).\n///\n/// These constants are used for encoding operation types in the 32-bit word format:\n/// - MSB set to 1 for ABSORB operations\n/// - MSB set to 0 for SQUEEZE operations\n\n/// Flag for ABSORB operations (MSB = 1)\nglobal ABSORB_FLAG: u32 = 0x80000000;\n\n/// Flag for SQUEEZE operations (MSB = 0)\nglobal SQUEEZE_FLAG: u32 = 0x00000000;\n\n/// SAFE Sponge State (following spec 2.2)\n///\n/// The sponge state consists of the permutation state, tag, position counters,\n/// and IO pattern tracking as defined in the SAFE specification.\n///\n/// # Generic Parameters\n/// - `L`: The length of the IO pattern array\n///\n/// # Fields\n/// - `state`: Permutation state V in F^n (rate + capacity elements)\n/// - `tag`: Parameter tag T used for instance differentiation\n/// - `absorb_pos`: Current absorb position (<= n-c)\n/// - `squeeze_pos`: Current squeeze position (<= n-c)\n/// - `io_pattern`: Expected IO pattern for validation (encoded 32-bit words)\n/// - `io_count`: Current operation count for pattern tracking\npub struct SafeSponge<let L: u32> {\n /// Permutation state V in F^n (rate + capacity elements).\n state: [Field; STATE_SIZE],\n /// Parameter tag T used for instance differentiation.\n tag: Field,\n /// Current absorb position (<= n-c).\n absorb_pos: u32,\n /// Current squeeze position (<= n-c).\n squeeze_pos: u32,\n /// Expected IO pattern for validation.\n io_pattern: [u32; L],\n /// Current operation count for pattern tracking (spec 2.4: io_count).\n io_count: u32,\n}\n\nimpl<let L: u32> SafeSponge<L> {\n /// Initializes a new SAFE sponge instance with the given IO pattern and domain separator (following spec 2.4).\n ///\n /// # Arguments\n /// - `io_pattern`: Array of 32-bit encoded operations defining the expected sequence of ABSORB/SQUEEZE calls.\n /// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n /// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n ///\n /// # Returns\n /// A new `SafeSponge` instance with initialized state\n pub fn start(io_pattern: [u32; L], domain_separator: [u8; 64]) -> SafeSponge<L> {\n // Compute tag from IO pattern and domain separator (spec 2.3).\n let tag = compute_tag(io_pattern, domain_separator);\n\n let mut state = [0; STATE_SIZE];\n // Initialize capacity with tag (spec 2.4).\n // Add T to the first 128 bits of the state.\n state[0] = tag;\n\n SafeSponge { state, tag, absorb_pos: 0, squeeze_pos: 0, io_pattern, io_count: 0 }\n }\n\n /// Absorbs field elements into the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to absorb is automatically validated against the IO pattern.\n /// This method accepts variable-length arrays, making it natural to use without padding.\n ///\n /// # Arguments\n /// - `input`: Array of field elements to absorb (variable length, must match IO pattern)\n pub fn absorb(&mut self, input: [Field]) {\n let length = input.len() as u32;\n\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_absorb = (expected_encoded_word & ABSORB_FLAG) != 0;\n let expected_length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type and length\n assert(is_expected_absorb, "Expected ABSORB operation");\n assert(expected_length == length, "Length mismatch");\n\n // Process each element naturally (no unnecessary iterations).\n for i in 0..length {\n // If absorb_pos == (n-c) then permute and reset (spec 2.4).\n if self.absorb_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.absorb_pos = 0;\n }\n\n // Add X[i] to state at absorb_pos (spec 2.4).\n // Note: absorb_pos is the rate position, not capacity position.\n self.state[self.absorb_pos + CAPACITY] =\n self.state[self.absorb_pos + CAPACITY] + input[i];\n self.absorb_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = ABSORB_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n\n // Force permute at start of next SQUEEZE (spec 2.4).\n self.squeeze_pos = RATE;\n }\n\n /// Extracts field elements from the sponge state, interleaving permutation calls as needed (following spec 2.4).\n ///\n /// The number of elements to squeeze is automatically determined from the IO pattern.\n pub fn squeeze(&mut self) -> [Field] {\n // Validate against IO pattern.\n assert(self.io_count < L);\n\n // Parse expected operation from io_pattern (encoded word)\n let expected_encoded_word = self.io_pattern[self.io_count];\n let is_expected_squeeze = (expected_encoded_word & ABSORB_FLAG) == 0;\n let length = expected_encoded_word & 0x7FFFFFFF;\n\n // Validate operation type\n assert(is_expected_squeeze, "Expected SQUEEZE operation");\n\n let mut output: [Field] = [].as_vector();\n\n // SQUEEZE implementation following spec 2.4.\n // If length==0, loop won\'t execute (spec 2.4).\n for _ in 0..length {\n // If squeeze_pos==(n-c) then permute and reset (spec 2.4).\n if self.squeeze_pos == RATE {\n // n-c = RATE.\n self.state = self.permute();\n self.squeeze_pos = 0;\n self.absorb_pos = 0;\n }\n // Set Y[i] to state element at squeeze_pos (spec 2.4).\n output = output.push_back(self.state[self.squeeze_pos + CAPACITY]);\n self.squeeze_pos += 1;\n }\n\n // Verify that the encoded word matches the expected pattern.\n let encoded_word = SQUEEZE_FLAG | length;\n assert(encoded_word == expected_encoded_word);\n\n self.io_count += 1;\n output\n }\n\n /// Finalizes the sponge instance, verifying that all expected operations have been performed and clearing the internal state for security (following spec 2.4).\n ///\n /// This function is used to ensure that the sponge instance has been used correctly and to prevent information leakage.\n pub fn finish(&mut self) {\n // Check that io_count equals the length of the IO pattern expected (spec 2.4).\n assert(self.io_count == L, "IO pattern not completed");\n\n // Erase the state and its variables (spec 2.4).\n self.state = [0; STATE_SIZE];\n self.absorb_pos = 0;\n self.squeeze_pos = 0;\n self.io_count = 0;\n }\n\n /// Permute the state using Poseidon2 (following spec 2.4).\n ///\n /// Applies the Poseidon2 permutation to the current state.\n /// This is the core cryptographic primitive of the sponge construction.\n ///\n /// # Returns\n /// New state after permutation\n fn permute(self) -> [Field; STATE_SIZE] {\n poseidon2_permutation(self.state)\n }\n}\n\n/// Computes a unique tag for a sponge instance based on its IO pattern and domain separator.\n/// The tag is used to ensure that distinct instances behave like distinct functions.\n///\n/// # Arguments\n/// - `io_pattern`: Array of 32-bit encoded operations defining the sponge\'s usage pattern.\n/// Each word has MSB=1 for ABSORB operations, MSB=0 for SQUEEZE operations.\n/// - `domain_separator`: 64-byte domain separator for cross-protocol security.\n///\n/// # Returns\n/// A field element representing the 128-bit tag.\npub fn compute_tag<let L: u32>(io_pattern: [u32; L], domain_separator: [u8; 64]) -> Field {\n // Step 1: Parse and aggregate consecutive operations of the same type\n let mut encoded_words = [0; L]; // Support up to L operations.\n let mut word_count = 0;\n let mut current_absorb_sum = 0;\n let mut current_squeeze_sum = 0;\n let mut last_was_absorb = false;\n\n for i in 0..L {\n if io_pattern[i] > 0 {\n // Parse operation type from MSB and length from lower 31 bits\n let is_absorb = (io_pattern[i] & ABSORB_FLAG) != 0;\n let length = io_pattern[i] & 0x7FFFFFFF; // Clear MSB to get length\n\n if is_absorb {\n if last_was_absorb {\n // Aggregate consecutive ABSORB operations\n current_absorb_sum += length;\n } else {\n // Start new ABSORB sequence\n if current_squeeze_sum > 0 {\n // Flush previous SQUEEZE sequence\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n current_squeeze_sum = 0;\n }\n current_absorb_sum = length;\n }\n last_was_absorb = true;\n } else {\n if !last_was_absorb {\n // Aggregate consecutive SQUEEZE operations\n current_squeeze_sum += length;\n } else {\n // Start new SQUEEZE sequence\n if current_absorb_sum > 0 {\n // Flush previous ABSORB sequence\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n current_absorb_sum = 0;\n }\n current_squeeze_sum = length;\n }\n last_was_absorb = false;\n }\n }\n }\n\n // Flush remaining operations\n if current_absorb_sum > 0 {\n encoded_words[word_count] = ABSORB_FLAG | current_absorb_sum;\n word_count += 1;\n }\n if current_squeeze_sum > 0 {\n encoded_words[word_count] = SQUEEZE_FLAG | current_squeeze_sum;\n word_count += 1;\n }\n\n // Step 2: Serialize to byte string and append domain separator (following SAFE spec 2.3).\n // Buffer is 256 bytes: max 192 bytes for IO pattern (48 words) + 64 bytes for domain separator.\n // Note: We must use a fixed-size array because Noir\'s keccak256 requires [u8; N], not [u8].\n let max_io_pattern_bytes: u32 = 192; // 256 - 64 (domain separator)\n let io_pattern_bytes = word_count * 4;\n assert(\n io_pattern_bytes <= max_io_pattern_bytes,\n "IO pattern too large: max 48 aggregated words supported",\n );\n\n let mut input_bytes = [0u8; 256];\n let mut byte_count: u32 = 0;\n\n // Serialize encoded words to bytes (big-endian as per SAFE spec).\n // Note: Noir requires compile-time loop bounds, so we iterate over L (the array size)\n // instead of word_count (runtime value). The condition `i < word_count` ensures we only\n // process valid encoded words. This is safe because word_count <= L always holds\n // (we can have at most L encoded words from L input operations).\n for i in 0..L {\n if i < word_count {\n let word = encoded_words[i];\n input_bytes[byte_count] = (word >> 24) as u8;\n input_bytes[byte_count + 1] = (word >> 16) as u8;\n input_bytes[byte_count + 2] = (word >> 8) as u8;\n input_bytes[byte_count + 3] = word as u8;\n byte_count += 4;\n }\n }\n\n // Append full 64-byte domain separator.\n for i in 0..64 {\n input_bytes[byte_count] = domain_separator[i];\n byte_count += 1;\n }\n\n // Step 3: Hash with Keccak-256 and truncate to 128 bits.\n // Note: The SAFE spec uses SHA3-256, but we use Keccak-256 for Noir compatibility.\n // Keccak-256 differs from SHA3-256 in padding, but both provide equivalent security.\n let hash_bytes = keccak256(input_bytes, byte_count);\n\n // Convert first 128 bits (16 bytes) to field element.\n let mut tag_value: Field = 0;\n for i in 0..16 {\n tag_value = tag_value * 256 + (hash_bytes[i] as Field);\n }\n\n tag_value\n}\n\n#[test]\nfn test_safe_hashing() {\n // Verifies basic hash functionality with a simple ABSORB(3) + SQUEEZE(1) pattern.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_merkle_node() {\n // Verifies SAFE can be used for Merkle tree node hashing with pattern ABSORB(1) + ABSORB(1) + SQUEEZE(1).\n // Tests the ability to absorb multiple inputs before squeezing output.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let left = [123].as_vector();\n let right = [456].as_vector();\n\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(left);\n sponge.absorb(right);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(left);\n sponge2.absorb(right);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_commitment_scheme() {\n // Verifies SAFE can be used for commitment schemes with pattern ABSORB(3) + SQUEEZE(1).\n // Tests the ability to create deterministic commitments from multiple field elements.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let values = [10, 20, 30].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(values);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n\n // Test determinism\n let mut sponge2 = SafeSponge::start(io_pattern, domain_separator);\n sponge2.absorb(values);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output2.len() == 1);\n assert(output2[0] != 0);\n}\n\n#[test]\nfn test_domain_separation() {\n // Verifies that different domain separators produce different outputs for the same input.\n // This is crucial for cross-protocol security and preventing collisions between different applications.\n let elements = [1, 2, 3].as_vector();\n let domain1 = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let domain2 = [\n 0x41, 0x42, 0x43, 0x45, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(3), SQUEEZE(1)\n let io_pattern = [0x80000003, 0x00000001];\n\n let mut sponge1 = SafeSponge::start(io_pattern, domain1);\n sponge1.absorb(elements);\n let output1 = sponge1.squeeze();\n sponge1.finish();\n\n let mut sponge2 = SafeSponge::start(io_pattern, domain2);\n sponge2.absorb(elements);\n let output2 = sponge2.squeeze();\n sponge2.finish();\n\n assert(output1.len() == 1);\n assert(output2.len() == 1);\n assert(output1[0] != output2[0]); // Different domain separators should produce different outputs\n}\n\n#[test]\nfn test_multiple_squeeze() {\n // Verifies that multiple field elements can be squeezed in a single operation.\n // Tests pattern ABSORB(3) + SQUEEZE(2) to ensure proper state management.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n let elements = [1, 2, 3].as_vector();\n\n // Pattern: ABSORB(3), SQUEEZE(2)\n let io_pattern = [0x80000003, 0x00000002];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb(elements);\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 2);\n assert(output[0] != 0);\n assert(output[1] != 0);\n assert(output[0] != output[1]); // Different squeeze outputs should be different\n}\n\n#[test]\nfn test_zero_length_operations() {\n // Verifies that zero-length ABSORB and SQUEEZE operations are handled correctly.\n // Tests pattern ABSORB(0) + SQUEEZE(1) to ensure proper state transitions.\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Pattern: ABSORB(0), SQUEEZE(1)\n let io_pattern = [0x80000000, 0x00000001];\n let mut sponge = SafeSponge::start(io_pattern, domain_separator);\n sponge.absorb([].as_vector());\n let output = sponge.squeeze();\n sponge.finish();\n\n assert(output.len() == 1);\n assert(output[0] != 0);\n}\n\n#[test]\nfn test_tag_computation() {\n // Verifies the tag computation algorithm using the example from the SAFE specification.\n // Pattern: ABSORB(3), ABSORB(3), SQUEEZE(3)\n // Should aggregate to: ABSORB(6), SQUEEZE(3)\n // Encoded as: [0x80000006, 0x00000003]\n // Tests determinism and pattern differentiation.\n\n let io_pattern = [0x80000003, 0x80000003, 0x00000003];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test determinism\n let tag2 = compute_tag(io_pattern, domain_separator);\n assert(tag == tag2);\n\n // Test that different patterns produce different tags\n let io_pattern2 = [0x80000003, 0x00000003]; // ABSORB(3), SQUEEZE(3) - different pattern\n let tag3 = compute_tag(io_pattern2, domain_separator);\n assert(tag != tag3);\n}\n\n#[test]\nfn test_tag_computation_debug() {\n println("=== SAFE Tag Computation Debug Test ===");\n\n // Test your specific pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))\n let io_pattern = [0x80000002, 0x00000002, 0x80000002];\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n println(f"Testing pattern: {io_pattern}");\n println(\n f"Expected to aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(2)",\n );\n println(\n f"Expected encoded words: [0x80000002, 0x00000002, 0x80000002]",\n );\n println("");\n\n let tag = compute_tag(io_pattern, domain_separator);\n\n println(f"=== Expected Rust Output ===");\n println("Pattern [2, 2, 2] (ABSORB(2), SQUEEZE(2), ABSORB(2))");\n println("Domain separator: 0x41424344...");\n println("Tag: 0xce3bb9ee4b2d41c42e9cdda38afe8b6a");\n println("");\n\n println(f"=== Noir Output ===");\n println(f"Tag: {tag}");\n println("");\n\n println("Compare the tag values above with Rust script!");\n}\n\n#[test]\nfn test_consecutive_absorb_aggregation() {\n // Test that consecutive ABSORB operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1) should aggregate to ABSORB(2), SQUEEZE(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(1) = [0x80000002, 0x00000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(2), SQUEEZE(1)\n let aggregated_pattern = [0x80000002, 0x00000001];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Consecutive ABSORB operations should aggregate to the same tag");\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive ABSORB operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive ABSORB Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001] (ABSORB(1), ABSORB(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000002, 0x00000001] (ABSORB(2), SQUEEZE(1))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_consecutive_squeeze_aggregation() {\n // Test that consecutive SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1) should aggregate to ABSORB(1), SQUEEZE(2)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), SQUEEZE(1), SQUEEZE(1)\n let io_pattern = [0x80000001, 0x00000001, 0x00000001];\n\n // This should aggregate to: ABSORB(1), SQUEEZE(2) = [0x80000001, 0x00000002]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag ABSORB(1), SQUEEZE(2)\n let aggregated_pattern = [0x80000001, 0x00000002];\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(\n tag == aggregated_tag,\n "Consecutive SQUEEZE operations should aggregate to the same tag",\n );\n\n // Test that a different pattern produces a different tag\n let different_pattern = [0x80000001, 0x00000001, 0x80000001]; // ABSORB(1), SQUEEZE(1), ABSORB(1)\n let different_tag = compute_tag(different_pattern, domain_separator);\n\n // This should be different because it doesn\'t have consecutive SQUEEZE operations\n assert(tag != different_tag, "Different patterns should produce different tags");\n\n println("=== Consecutive SQUEEZE Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x00000001, 0x00000001] (ABSORB(1), SQUEEZE(1), SQUEEZE(1))",\n );\n println(\n f"Aggregated pattern: [0x80000001, 0x00000002] (ABSORB(1), SQUEEZE(2))",\n );\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n println(f"Different pattern tag: {different_tag}");\n}\n\n#[test]\nfn test_mixed_consecutive_aggregation() {\n // Test that both consecutive ABSORB and SQUEEZE operations are properly aggregated\n // Pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n // Should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1)\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Test pattern: ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1)\n let io_pattern = [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001];\n\n // This should aggregate to: ABSORB(2), SQUEEZE(2), ABSORB(1) = [0x80000002, 0x00000002, 0x80000001]\n let tag = compute_tag(io_pattern, domain_separator);\n\n // Test that the aggregated pattern produces the same tag\n let aggregated_pattern = [0x80000002, 0x00000002, 0x80000001]; // ABSORB(2), SQUEEZE(2), ABSORB(1)\n let aggregated_tag = compute_tag(aggregated_pattern, domain_separator);\n\n // The tags should be identical because the patterns are equivalent after aggregation\n assert(tag == aggregated_tag, "Mixed consecutive operations should aggregate to the same tag");\n\n println("=== Mixed Consecutive Aggregation Test ===");\n println(\n f"Original pattern: [0x80000001, 0x80000001, 0x00000001, 0x00000001, 0x80000001]",\n );\n println(\n f" (ABSORB(1), ABSORB(1), SQUEEZE(1), SQUEEZE(1), ABSORB(1))",\n );\n println(f"Aggregated pattern: [0x80000002, 0x00000002, 0x80000001]");\n println(f" (ABSORB(2), SQUEEZE(2), ABSORB(1))");\n println(f"Original tag: {tag}");\n println(f"Aggregated tag: {aggregated_tag}");\n}\n\n#[test]\nfn test_large_io_pattern() {\n let domain_separator = [\n 0x41, 0x42, 0x43, 0x44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0, 0, 0, 0,\n ];\n\n // Create pattern with 48 alternating ABSORB(1) and SQUEEZE(1) operations\n // This is the maximum supported (48 words * 4 bytes = 192 bytes, leaving 64 for domain separator)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1; // ABSORB(1)\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1; // SQUEEZE(1)\n }\n }\n\n let tag = compute_tag(io_pattern, domain_separator);\n assert(tag != 0);\n}\n\n#[test]\nfn test_domain_separator_not_truncated() {\n // This test verifies that the domain separator is always included in the tag computation,\n // even for large IO patterns. If the domain separator were truncated, different domain\n // separators would produce the same tag for large patterns.\n\n let domain_separator_a = [\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n 0x41, 0x41, 0x41, 0x41,\n ]; // All \'A\'s\n\n let domain_separator_b = [\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42,\n 0x42, 0x42, 0x42, 0x42,\n ]; // All \'B\'s\n\n // Create pattern with 48 alternating operations (max supported: 192 bytes of IO pattern)\n let mut io_pattern = [0u32; 48];\n for i in 0..48 {\n if i % 2 == 0 {\n io_pattern[i] = ABSORB_FLAG | 1;\n } else {\n io_pattern[i] = SQUEEZE_FLAG | 1;\n }\n }\n\n let tag_a = compute_tag(io_pattern, domain_separator_a);\n let tag_b = compute_tag(io_pattern, domain_separator_b);\n\n // Tags MUST be different because domain separators are different.\n // If they were the same, it would mean the domain separator was truncated/ignored.\n assert(tag_a != tag_b, "Domain separator must affect tag even for large IO patterns");\n}\n', path: "interfold/circuits/lib/src/math/safe.nr", function_locations: [{ start: 4164, name: "SafeSponge<L>::start" }, { start: 5046, name: "SafeSponge<L>::absorb" }, { start: 6826, name: "SafeSponge<L>::squeeze" }, { start: 8494, name: "SafeSponge<L>::finish" }, { start: 9156, name: "SafeSponge<L>::permute" }, { start: 9830, name: "compute_tag" }, { start: 14128, name: "test_safe_hashing" }, { start: 15104, name: "test_merkle_node" }, { start: 16281, name: "test_commitment_scheme" }, { start: 17357, name: "test_domain_separation" }, { start: 18710, name: "test_multiple_squeeze" }, { start: 19639, name: "test_zero_length_operations" }, { start: 20415, name: "test_tag_computation" }, { start: 21477, name: "test_tag_computation_debug" }, { start: 22681, name: "test_consecutive_absorb_aggregation" }, { start: 24750, name: "test_consecutive_squeeze_aggregation" }, { start: 26760, name: "test_mixed_consecutive_aggregation" }, { start: 28520, name: "test_large_io_pattern" }, { start: 29333, name: "test_domain_separator_not_truncated" }] } } };
12
+
13
+ // src/presets/insecure-64.ts
14
+ var preset = "insecure-64";
15
+ var loadCircuits = async () => ({
16
+ preset,
17
+ crisp: crisp_default,
18
+ crispOnchain: crisp_onchain_default,
19
+ userDataEncryptionCt0: user_data_encryption_ct0_default,
20
+ userDataEncryptionCt1: user_data_encryption_ct1_default
21
+ });
22
+ export {
23
+ loadCircuits,
24
+ preset
25
+ };
26
+ //# sourceMappingURL=insecure-64.js.map