diff --git a/benchmarking-suite/frameworks/noir/circuits/anemoi/Nargo.toml b/benchmarking-suite/frameworks/noir/circuits/anemoi/Nargo.toml new file mode 100644 index 00000000..1014b0d0 --- /dev/null +++ b/benchmarking-suite/frameworks/noir/circuits/anemoi/Nargo.toml @@ -0,0 +1,6 @@ +[package] +name = "anemoi" +type = "bin" +authors = [""] + +[dependencies] \ No newline at end of file diff --git a/benchmarking-suite/frameworks/noir/circuits/anemoi/Prover.toml b/benchmarking-suite/frameworks/noir/circuits/anemoi/Prover.toml new file mode 100644 index 00000000..af8bacab --- /dev/null +++ b/benchmarking-suite/frameworks/noir/circuits/anemoi/Prover.toml @@ -0,0 +1,2 @@ +bytes = ["72", "101", "108", "108", "111", "32", "87", "111", "114", "108", "100", "33", "32", "84", "104", "105", "115", "32", "105", "115", "32", "97", "32", "116", "101", "115", "116", "32", "109", "115", "103", "46", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0"] +message_len = "32" diff --git a/benchmarking-suite/frameworks/noir/circuits/anemoi/src/main.nr b/benchmarking-suite/frameworks/noir/circuits/anemoi/src/main.nr new file mode 100644 index 00000000..14656eb2 --- /dev/null +++ b/benchmarking-suite/frameworks/noir/circuits/anemoi/src/main.nr @@ -0,0 +1,269 @@ +global RATE: u32 = 3; +global CAPACITY: u32 = 1; +global GROUP_GENERATOR: Field = 3; +global NUM_HASH_ROUNDS: u32 = 14; +global NUM_COLUMNS: u32 = 2; +global DELTA: Field = 14592161914559516814830937163504850059130874104865215775126025263096817472389; +global STATE_WIDTH: u32 = RATE + CAPACITY; // 4 +pub global MAX_BYTES: u32 = 124; // 4*31 +pub global DIGEST_SIZE: u32 = 1; // Field +global ROUND_CONSTANTS_C: [Field; NUM_COLUMNS * NUM_HASH_ROUNDS] = [ + 35, + 10728830232125876048691132003354346755586467280684666879763784946929486129763, + 6295152911226189444253866884160054349659895788778004607372136398144290407549, + 4170461203170338529741796292530969989683534808908029969258349139824859915904, + 21393954857409224592174814995535004102448434148992032619414656579779568689397, + 19103935993755851832506530394984072115477780447437172722727915763091375333078, + 2634462417634249118966770176700483350170452174029521955965196796017381401956, + 9870055416920542367693949347356159207100758622575243892551291274828474900748, + 15295217319366023946214435818896821054815840546749644406149416251837787741809, + 21367629723253304595356008437306437873020250932614372155612389587750289867011, + 4897740601044642812417701466299626155416058382941267461556139867957028325237, + 4324119087587322124992127934008257335151923347457111258041741869609415314621, + 5767392289724148929423693389240961480732135563465616880868228443921968183406, + 6456395601221278483898856214412953805799588482438919310023101480520873192872, + 5317720115970311700954487800253539185353124589203406383093606299177363378965, + 710253803690889095236417604443336282363034988531359282506781126270380345614, + 7178683072420401867285583491757519765705805053793732990705659310878562779654, + 13327114523820687328947491054908536262979380425435492467096400458206660578625, + 2383742814212199693233039241857741773656918170662619722497679382455110461025, + 20164900203441302184815429722225772605937488447067719903152256866067450079451, + 21825004911469755557450894072491638633707168470327514863312230079098931792558, + 19511933942982909833130072835044780778916343397900214764221687167599966064505, + 21450247751664710150210987593785515492243624894603811466130600962437485349126, + 13060233182408841069732007751789764082800198352477853683638512640473860490294, + 19967544120700448884148022659483814768484183439673469569018785205921257830429, + 10084871904716023332756110794661983037429784294614615895805562029971540034206, + 18386115521729639027684330339118321986942103783973318486465519864576242574862, + 867700948464676294883210265244989471599975912890168408823467958647230813300, +]; + +global ROUND_CONSTANTS_D: [Field; NUM_COLUMNS * NUM_HASH_ROUNDS] = [ + 14592161914559516814830937163504850059130874104865215775126025263096817472424, + 19360043162052512507098157693689938349509928124442079135790346009357484115856, + 14886328771476750059923328797989224350922636562469070718728625674557930694836, + 6800688078788018788987346733190881525738862321491292561515374215569680716895, + 19638893102775796275277235225427456246362977103230584685008442902017466767651, + 11387925254489543159185039151707265794184910140567921269222237884660453925036, + 1787913011046289936440351532682066056745691701271258002538193117792994935178, + 3062557025699702828743619230168483448468584888709176420024823395935268947674, + 6540948924772883830594916229804018068216315941466299076736273903153878004006, + 6652412344027284123312577375044376421213313066223223307099783038397560642912, + 9293040363042818517653611216357198985940406678571067812961313240862902841192, + 2758469864952617473804126210896571700468858381979108090347451041846470344280, + 20658070995971503522675594453880534996148127144823809317500067332141426153766, + 15386125322835752720726845805883268856008166802689308227555476168071511676936, + 16109693438097508500290383924735749637046547901319402337827102095664399270999, + 5541278141185205538148402255756288268849045039539551718140812722088596751352, + 18656175406244756418120480628945495368630959223459057438730888996407700600910, + 18843657873012161523358476718927253400697121333993013396022165943066978913585, + 12502826677069997362424575811268729535889132287156664980829561599509861883271, + 2434792209826944275336649073210226814265978145156137979695636987808155806818, + 16259278398410221045718709682000965909307495157015098081392577671769584472840, + 7985258445290494964973976971384849589309256823479994463202570559601799258491, + 5279985636464436227957162207029856553960115578931399779648839709840928288577, + 12817264954414962013300676637122121768005586932995462140746325081853710152032, + 10994211793969826214874362360644675501561401171942888501268420197333659245365, + 17038833465191795529304944767910860393995899923074054971644770715360348171429, + 19252379911722914953209805612883583535327217956088185615886897738157450269129, + 17661259225664347086231179811098267643473987981195055681834419526204845229854, +]; + +global INV_ALPHA: Field = + 17510594297471420177797124596205820070838691520332827474958563349260646796493; + +fn mul_by_generator(x: Field) -> Field { + x * GROUP_GENERATOR +} + +unconstrained fn pow_unconstrained(base: Field) -> Field { + let exp = INV_ALPHA; + let mut res: Field = 1; + // We explicitly tell the compiler to decompose into 254 bits + let bits = exp.to_le_bits::<254>(); + + for i in 0..254 { + // Square first (except possibly the very first iteration, + // but squaring 1 is still 1, so this is safe) + res *= res; + + // If the bit is 1, multiply by the base + // Note: bits[253 - i] accesses the bits from Most Significant to Least Significant + if bits[253 - i] == 1 { + res *= base; + } + } + res +} + +fn exp_by_inv_alpha(x: Field) -> Field { + // Safety: The result is constrained by the assertion below: assert(x == out_4 * out); + let out = unsafe { pow_unconstrained(x) }; + + // 2. Constrain the result (Secure) + // This is where the 3 gates come in. + let out_2 = out * out; + let out_4 = out_2 * out_2; + assert(x == out_4 * out); // Verifies out^5 == x + + out +} + +fn apply_ark_layer(state: &mut [Field; STATE_WIDTH], round_counter: u32) { + state[0] += ROUND_CONSTANTS_C[round_counter * NUM_COLUMNS]; + state[1] += ROUND_CONSTANTS_C[round_counter * NUM_COLUMNS + 1]; + state[2] += ROUND_CONSTANTS_D[round_counter * NUM_COLUMNS]; + state[3] += ROUND_CONSTANTS_D[round_counter * NUM_COLUMNS + 1]; +} + +fn apply_mds_layer(state: &mut [Field; STATE_WIDTH]) { + // apply MDS matrix + state[0] += mul_by_generator(state[1]); + state[1] += mul_by_generator(state[0]); + state[3] += mul_by_generator(state[2]); + state[2] += mul_by_generator(state[3]); + // Swap + let x = state[2]; + state[2] = state[3]; + state[3] = x; + //PHT layer + state[2] += state[0]; + state[3] += state[1]; + state[0] += state[2]; + state[1] += state[3]; +} + +fn apply_sbox(state: &mut [Field; STATE_WIDTH]) { + let mut x: [Field; NUM_COLUMNS] = [state[0], state[1]]; + let mut y: [Field; NUM_COLUMNS] = [state[2], state[3]]; + for i in 0..NUM_COLUMNS { + let y2 = y[i] * y[i]; + x[i] = x[i] - mul_by_generator(y2); + } + let mut x_alpha_inv: [Field; NUM_COLUMNS] = [0; NUM_COLUMNS]; + for i in 0..NUM_COLUMNS { + x_alpha_inv[i] = exp_by_inv_alpha(x[i]); + } + + // y[i] -= x_alpha_inv[i] + for i in 0..NUM_COLUMNS { + y[i] = y[i] - x_alpha_inv[i]; + } + + // x[i] = x[i] + g * y[i]^2 + DELTA + for i in 0..NUM_COLUMNS { + let y2 = y[i] * y[i]; + x[i] = x[i] + GROUP_GENERATOR * y2 + DELTA; + } + + for i in 0..NUM_COLUMNS { + state[i] = x[i]; + state[i + NUM_COLUMNS] = y[i]; + } +} + +fn anemoi_permutation(state: &mut [Field; STATE_WIDTH]) { + for round in 0..NUM_HASH_ROUNDS { + apply_ark_layer(state, round); + apply_mds_layer(state); + apply_sbox(state); + } + apply_mds_layer(state); +} + +fn bytes31_to_field(bytes: [u8; 31]) -> Field { + let mut acc: Field = 0; + let mut base: Field = 1; + + for i in 0..31 { + acc = acc + base * (bytes[i] as Field); + base = base * 256; + } + + acc +} + +fn get_padded_chunk(bytes: [u8; MAX_BYTES], message_len: u32, chunk_idx: u32) -> [u8; 31] { + let mut out = [0u8; 31]; + let start = chunk_idx * 31; + + for i in 0..31 { + let idx = start + i; + + if idx < message_len { + out[i] = bytes[idx]; + } else if idx == message_len { + out[i] = 1; // padding byte + } + } + + out +} + +pub fn main(bytes: [u8; MAX_BYTES], message_len: u32) -> pub [Field; DIGEST_SIZE] { + // ------------------------------------------------ + // 1. Compute number of field elements + // ------------------------------------------------ + let mut num_elements = message_len / 31; + if message_len % 31 != 0 { + num_elements += 1; + } + + // ------------------------------------------------ + // 2. Compute sigma + // ------------------------------------------------ + let mut sigma: Field = 0; + if num_elements % RATE == 0 { + sigma = 1; + } + + // ------------------------------------------------ + // 3. Initialize state + // ------------------------------------------------ + let mut state = [0 as Field; STATE_WIDTH]; + + // ------------------------------------------------ + // 4. Absorption phase + // ------------------------------------------------ + let mut rate_idx: u32 = 0; + let mut absorbed: u32 = 0; + + for chunk_idx in 0..4 { + if chunk_idx < num_elements { + let chunk = get_padded_chunk(bytes, message_len, chunk_idx); + let fe = bytes31_to_field(chunk); + + state[rate_idx] = state[rate_idx] + fe; + rate_idx += 1; + + if rate_idx == RATE { + anemoi_permutation(&mut state); + rate_idx = 0; + absorbed += RATE; + } + } + } + + // ------------------------------------------------ + // 5. Add sigma to capacity + // ------------------------------------------------ + state[STATE_WIDTH - 1] = state[STATE_WIDTH - 1] + sigma; + + // ------------------------------------------------ + // 6. Final padding if needed + // ------------------------------------------------ + if sigma == 0 { + state[rate_idx] = state[rate_idx] + 1; + anemoi_permutation(&mut state); + } + + // ------------------------------------------------ + // 7. Squeeze digest + // ------------------------------------------------ + let mut digest = [0 as Field; DIGEST_SIZE]; + for i in 0..DIGEST_SIZE { + digest[i] = state[i]; + } + + digest +} diff --git a/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.gz b/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.gz new file mode 100644 index 00000000..87a208f2 Binary files /dev/null and b/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.gz differ diff --git a/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.json b/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.json new file mode 100644 index 00000000..2a438265 --- /dev/null +++ b/benchmarking-suite/frameworks/noir/circuits/anemoi/target/anemoi.json @@ -0,0 +1 @@ +{"noir_version":"1.0.0-beta.8+ba05d729b9753aa5ce2b076c1dd4795edb173f68","hash":"3497547604049852497","abi":{"parameters":[{"name":"bytes","type":{"kind":"array","length":124,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"message_len","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"return_type":{"abi_type":{"kind":"array","length":1,"type":{"kind":"field"}},"visibility":"public"},"error_types":{"2920182694213909827":{"error_kind":"string","string":"attempt to subtract with overflow"},"5019202896831570965":{"error_kind":"string","string":"attempt to add with overflow"},"14225679739041873922":{"error_kind":"string","string":"Index out of bounds"},"17843811134343075018":{"error_kind":"string","string":"Stack too deep"}}},"bytecode":"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","debug_symbols":"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","file_map":{"18":{"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(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 `[u1; N]` array.\n /// This slice 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 slice 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(self: Self) -> [u1; 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] == 1);\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 `[u1; 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 slice 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(self: Self) -> [u1; 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] == 1);\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(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(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(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(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: [u1; 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) = 0 if x `elem` {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n pub fn sgn0(self) -> u1 {\n self as u1\n }\n\n pub fn lt(self, another: Field) -> bool {\n if crate::compat::is_bn254() {\n bn254_lt(self, another)\n } else {\n lt_fallback(self, another)\n }\n }\n\n /// Convert a little endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_le_bytes(bytes: [u8; N]) -> Field {\n static_assert(\n N <= modulus_le_bytes().len(),\n \"N must be less than or equal to modulus_le_bytes().len()\",\n );\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[i] as Field) * v;\n v = v * 256;\n }\n result\n }\n\n /// Convert a big endian byte array to a field element.\n /// If the provided byte array overflows the field modulus then the Field will silently wrap around.\n pub fn from_be_bytes(bytes: [u8; N]) -> Field {\n let mut v = 1;\n let mut result = 0;\n\n for i in 0..N {\n result += (bytes[N - 1 - i] as Field) * v;\n v = v * 256;\n }\n result\n }\n}\n\n#[builtin(apply_range_constraint)]\nfn __assert_max_bit_size(value: Field, bit_size: u32) {}\n\n// `_radix` must be less than 256\n#[builtin(to_le_radix)]\nfn __to_le_radix(value: Field, radix: u32) -> [u8; N] {}\n\n// `_radix` must be less than 256\n#[builtin(to_be_radix)]\nfn __to_be_radix(value: Field, radix: u32) -> [u8; N] {}\n\n/// Decomposes `self` into its little endian bit decomposition as a `[u1; N]` array.\n/// This slice 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 slice 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(value: Field) -> [u1; N] {}\n\n/// Decomposes `self` into its big endian bit decomposition as a `[u1; 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 slice 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(value: Field) -> [u1; 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() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n/// An unconstrained only built in to efficiently compare fields.\n#[builtin(field_less_than)]\nunconstrained fn __field_less_than(x: Field, y: Field) -> bool {}\n\npub(crate) unconstrained fn field_less_than(x: Field, y: Field) -> bool {\n __field_less_than(x, y)\n}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n // Convert it to a field element\n let mut v = 1;\n let mut high = 0 as Field;\n let mut low = 0 as Field;\n\n for i in 0..16 {\n high = high + (bytes32[15 - i] as Field) * v;\n low = low + (bytes32[16 + 15 - i] as Field) * v;\n v = v * 256;\n }\n // Abuse that a % p + b % p = (a + b) % p and that low < p\n low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n if is_unconstrained() {\n // Safety: unconstrained context\n unsafe {\n field_less_than(x, y)\n }\n } else {\n let x_bytes: [u8; 32] = x.to_le_bytes();\n let y_bytes: [u8; 32] = y.to_le_bytes();\n let mut x_is_lt = false;\n let mut done = false;\n for i in 0..32 {\n if (!done) {\n let x_byte = x_bytes[32 - 1 - i] as u8;\n let y_byte = y_bytes[32 - 1 - i] as u8;\n let bytes_match = x_byte == y_byte;\n if !bytes_match {\n x_is_lt = x_byte < y_byte;\n done = true;\n }\n }\n }\n x_is_lt\n }\n}\n\nmod tests {\n use crate::{panic::panic, runtime};\n use super::field_less_than;\n\n #[test]\n // docs:start:to_be_bits_example\n fn test_to_be_bits() {\n let field = 2;\n let bits: [u1; 8] = field.to_be_bits();\n assert_eq(bits, [0, 0, 0, 0, 0, 0, 1, 0]);\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: [u1; 8] = field.to_le_bits();\n assert_eq(bits, [0, 1, 0, 0, 0, 0, 0, 0]);\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(f\"radix must be greater than 1\");\n }\n }\n\n // TODO: Update this test to account for the Brillig restriction that the radix must be greater than 2\n //#[test]\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 out: [u8; 8] = field.to_le_radix(1);\n // crate::println(out);\n // let expected = [0; 8];\n // assert(out == expected, \"unexpected result\");\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(f\"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(f\"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 // TODO: Update this test to account for the Brillig restriction that the radix must be less than 512\n //#[test]\n //fn test_to_le_radix_brillig_512() {\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(512);\n // let mut expected = [0; 8];\n // expected[0] = 1;\n // assert(out == expected, \"unexpected result\");\n // }\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","path":"std/field/mod.nr"},"50":{"source":"global RATE: u32 = 3;\nglobal CAPACITY: u32 = 1;\nglobal GROUP_GENERATOR: Field = 3;\nglobal NUM_HASH_ROUNDS: u32 = 14;\nglobal NUM_COLUMNS: u32 = 2;\nglobal DELTA: Field = 14592161914559516814830937163504850059130874104865215775126025263096817472389;\nglobal STATE_WIDTH: u32 = RATE + CAPACITY; // 4\npub global MAX_BYTES: u32 = 124; // 4*31\npub global DIGEST_SIZE: u32 = 1; // Field\nglobal ROUND_CONSTANTS_C: [Field; NUM_COLUMNS * NUM_HASH_ROUNDS] = [\n 35,\n 10728830232125876048691132003354346755586467280684666879763784946929486129763,\n 6295152911226189444253866884160054349659895788778004607372136398144290407549,\n 4170461203170338529741796292530969989683534808908029969258349139824859915904,\n 21393954857409224592174814995535004102448434148992032619414656579779568689397,\n 19103935993755851832506530394984072115477780447437172722727915763091375333078,\n 2634462417634249118966770176700483350170452174029521955965196796017381401956,\n 9870055416920542367693949347356159207100758622575243892551291274828474900748,\n 15295217319366023946214435818896821054815840546749644406149416251837787741809,\n 21367629723253304595356008437306437873020250932614372155612389587750289867011,\n 4897740601044642812417701466299626155416058382941267461556139867957028325237,\n 4324119087587322124992127934008257335151923347457111258041741869609415314621,\n 5767392289724148929423693389240961480732135563465616880868228443921968183406,\n 6456395601221278483898856214412953805799588482438919310023101480520873192872,\n 5317720115970311700954487800253539185353124589203406383093606299177363378965,\n 710253803690889095236417604443336282363034988531359282506781126270380345614,\n 7178683072420401867285583491757519765705805053793732990705659310878562779654,\n 13327114523820687328947491054908536262979380425435492467096400458206660578625,\n 2383742814212199693233039241857741773656918170662619722497679382455110461025,\n 20164900203441302184815429722225772605937488447067719903152256866067450079451,\n 21825004911469755557450894072491638633707168470327514863312230079098931792558,\n 19511933942982909833130072835044780778916343397900214764221687167599966064505,\n 21450247751664710150210987593785515492243624894603811466130600962437485349126,\n 13060233182408841069732007751789764082800198352477853683638512640473860490294,\n 19967544120700448884148022659483814768484183439673469569018785205921257830429,\n 10084871904716023332756110794661983037429784294614615895805562029971540034206,\n 18386115521729639027684330339118321986942103783973318486465519864576242574862,\n 867700948464676294883210265244989471599975912890168408823467958647230813300,\n];\n\nglobal ROUND_CONSTANTS_D: [Field; NUM_COLUMNS * NUM_HASH_ROUNDS] = [\n 14592161914559516814830937163504850059130874104865215775126025263096817472424,\n 19360043162052512507098157693689938349509928124442079135790346009357484115856,\n 14886328771476750059923328797989224350922636562469070718728625674557930694836,\n 6800688078788018788987346733190881525738862321491292561515374215569680716895,\n 19638893102775796275277235225427456246362977103230584685008442902017466767651,\n 11387925254489543159185039151707265794184910140567921269222237884660453925036,\n 1787913011046289936440351532682066056745691701271258002538193117792994935178,\n 3062557025699702828743619230168483448468584888709176420024823395935268947674,\n 6540948924772883830594916229804018068216315941466299076736273903153878004006,\n 6652412344027284123312577375044376421213313066223223307099783038397560642912,\n 9293040363042818517653611216357198985940406678571067812961313240862902841192,\n 2758469864952617473804126210896571700468858381979108090347451041846470344280,\n 20658070995971503522675594453880534996148127144823809317500067332141426153766,\n 15386125322835752720726845805883268856008166802689308227555476168071511676936,\n 16109693438097508500290383924735749637046547901319402337827102095664399270999,\n 5541278141185205538148402255756288268849045039539551718140812722088596751352,\n 18656175406244756418120480628945495368630959223459057438730888996407700600910,\n 18843657873012161523358476718927253400697121333993013396022165943066978913585,\n 12502826677069997362424575811268729535889132287156664980829561599509861883271,\n 2434792209826944275336649073210226814265978145156137979695636987808155806818,\n 16259278398410221045718709682000965909307495157015098081392577671769584472840,\n 7985258445290494964973976971384849589309256823479994463202570559601799258491,\n 5279985636464436227957162207029856553960115578931399779648839709840928288577,\n 12817264954414962013300676637122121768005586932995462140746325081853710152032,\n 10994211793969826214874362360644675501561401171942888501268420197333659245365,\n 17038833465191795529304944767910860393995899923074054971644770715360348171429,\n 19252379911722914953209805612883583535327217956088185615886897738157450269129,\n 17661259225664347086231179811098267643473987981195055681834419526204845229854,\n];\n\nglobal INV_ALPHA: Field =\n 17510594297471420177797124596205820070838691520332827474958563349260646796493;\n\nfn mul_by_generator(x: Field) -> Field {\n x * GROUP_GENERATOR\n}\n\nunconstrained fn pow_unconstrained(base: Field) -> Field {\n let exp = INV_ALPHA;\n let mut res: Field = 1;\n // We explicitly tell the compiler to decompose into 254 bits\n let bits = exp.to_le_bits::<254>();\n\n for i in 0..254 {\n // Square first (except possibly the very first iteration,\n // but squaring 1 is still 1, so this is safe)\n res *= res;\n\n // If the bit is 1, multiply by the base\n // Note: bits[253 - i] accesses the bits from Most Significant to Least Significant\n if bits[253 - i] == 1 {\n res *= base;\n }\n }\n res\n}\n\nfn exp_by_inv_alpha(x: Field) -> Field {\n // Safety: The result is constrained by the assertion below: assert(x == out_4 * out);\n let out = unsafe { pow_unconstrained(x) };\n\n // 2. Constrain the result (Secure)\n // This is where the 3 gates come in.\n let out_2 = out * out;\n let out_4 = out_2 * out_2;\n assert(x == out_4 * out); // Verifies out^5 == x\n\n out\n}\n\nfn apply_ark_layer(state: &mut [Field; STATE_WIDTH], round_counter: u32) {\n state[0] += ROUND_CONSTANTS_C[round_counter * NUM_COLUMNS];\n state[1] += ROUND_CONSTANTS_C[round_counter * NUM_COLUMNS + 1];\n state[2] += ROUND_CONSTANTS_D[round_counter * NUM_COLUMNS];\n state[3] += ROUND_CONSTANTS_D[round_counter * NUM_COLUMNS + 1];\n}\n\nfn apply_mds_layer(state: &mut [Field; STATE_WIDTH]) {\n // apply MDS matrix\n state[0] += mul_by_generator(state[1]);\n state[1] += mul_by_generator(state[0]);\n state[3] += mul_by_generator(state[2]);\n state[2] += mul_by_generator(state[3]);\n // Swap\n let x = state[2];\n state[2] = state[3];\n state[3] = x;\n //PHT layer\n state[2] += state[0];\n state[3] += state[1];\n state[0] += state[2];\n state[1] += state[3];\n}\n\nfn apply_sbox(state: &mut [Field; STATE_WIDTH]) {\n let mut x: [Field; NUM_COLUMNS] = [state[0], state[1]];\n let mut y: [Field; NUM_COLUMNS] = [state[2], state[3]];\n for i in 0..NUM_COLUMNS {\n let y2 = y[i] * y[i];\n x[i] = x[i] - mul_by_generator(y2);\n }\n let mut x_alpha_inv: [Field; NUM_COLUMNS] = [0; NUM_COLUMNS];\n for i in 0..NUM_COLUMNS {\n x_alpha_inv[i] = exp_by_inv_alpha(x[i]);\n }\n\n // y[i] -= x_alpha_inv[i]\n for i in 0..NUM_COLUMNS {\n y[i] = y[i] - x_alpha_inv[i];\n }\n\n // x[i] = x[i] + g * y[i]^2 + DELTA\n for i in 0..NUM_COLUMNS {\n let y2 = y[i] * y[i];\n x[i] = x[i] + GROUP_GENERATOR * y2 + DELTA;\n }\n\n for i in 0..NUM_COLUMNS {\n state[i] = x[i];\n state[i + NUM_COLUMNS] = y[i];\n }\n}\n\nfn anemoi_permutation(state: &mut [Field; STATE_WIDTH]) {\n for round in 0..NUM_HASH_ROUNDS {\n apply_ark_layer(state, round);\n apply_mds_layer(state);\n apply_sbox(state);\n }\n apply_mds_layer(state);\n}\n\nfn bytes31_to_field(bytes: [u8; 31]) -> Field {\n let mut acc: Field = 0;\n let mut base: Field = 1;\n\n for i in 0..31 {\n acc = acc + base * (bytes[i] as Field);\n base = base * 256;\n }\n\n acc\n}\n\nfn get_padded_chunk(bytes: [u8; MAX_BYTES], message_len: u32, chunk_idx: u32) -> [u8; 31] {\n let mut out = [0u8; 31];\n let start = chunk_idx * 31;\n\n for i in 0..31 {\n let idx = start + i;\n\n if idx < message_len {\n out[i] = bytes[idx];\n } else if idx == message_len {\n out[i] = 1; // padding byte\n }\n }\n\n out\n}\n\npub fn main(bytes: [u8; MAX_BYTES], message_len: u32) -> pub [Field; DIGEST_SIZE] {\n // ------------------------------------------------\n // 1. Compute number of field elements\n // ------------------------------------------------\n let mut num_elements = message_len / 31;\n if message_len % 31 != 0 {\n num_elements += 1;\n }\n\n // ------------------------------------------------\n // 2. Compute sigma\n // ------------------------------------------------\n let mut sigma: Field = 0;\n if num_elements % RATE == 0 {\n sigma = 1;\n }\n\n // ------------------------------------------------\n // 3. Initialize state\n // ------------------------------------------------\n let mut state = [0 as Field; STATE_WIDTH];\n\n // ------------------------------------------------\n // 4. Absorption phase\n // ------------------------------------------------\n let mut rate_idx: u32 = 0;\n let mut absorbed: u32 = 0;\n\n for chunk_idx in 0..4 {\n if chunk_idx < num_elements {\n let chunk = get_padded_chunk(bytes, message_len, chunk_idx);\n let fe = bytes31_to_field(chunk);\n\n state[rate_idx] = state[rate_idx] + fe;\n rate_idx += 1;\n\n if rate_idx == RATE {\n anemoi_permutation(&mut state);\n rate_idx = 0;\n absorbed += RATE;\n }\n }\n }\n\n // ------------------------------------------------\n // 5. Add sigma to capacity\n // ------------------------------------------------\n state[STATE_WIDTH - 1] = state[STATE_WIDTH - 1] + sigma;\n\n // ------------------------------------------------\n // 6. Final padding if needed\n // ------------------------------------------------\n if sigma == 0 {\n state[rate_idx] = state[rate_idx] + 1;\n anemoi_permutation(&mut state);\n }\n\n // ------------------------------------------------\n // 7. Squeeze digest\n // ------------------------------------------------\n let mut digest = [0 as Field; DIGEST_SIZE];\n for i in 0..DIGEST_SIZE {\n digest[i] = state[i];\n }\n\n digest\n}\n","path":"/home/yash/anemoi/src/main.nr"}},"names":["main"],"brillig_names":["pow_unconstrained","directive_integer_quotient","directive_invert"]} \ No newline at end of file